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