The Tor Browser / file comparison
comparison: intl/icu/source/common/ucnv_cb.c
intl/icu/source/common/ucnv_cb.c
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:c8df5816de60 |
|---|---|
| 1 /* | |
| 2 ********************************************************************** | |
| 3 * Copyright (C) 2000-2006, International Business Machines | |
| 4 * Corporation and others. All Rights Reserved. | |
| 5 ********************************************************************** | |
| 6 * ucnv_cb.c: | |
| 7 * External APIs for the ICU's codeset conversion library | |
| 8 * Helena Shih | |
| 9 * | |
| 10 * Modification History: | |
| 11 * | |
| 12 * Date Name Description | |
| 13 * 7/28/2000 srl Implementation | |
| 14 */ | |
| 15 | |
| 16 /** | |
| 17 * @name Character Conversion C API | |
| 18 * | |
| 19 */ | |
| 20 | |
| 21 #include "unicode/utypes.h" | |
| 22 | |
| 23 #if !UCONFIG_NO_CONVERSION | |
| 24 | |
| 25 #include "unicode/ucnv_cb.h" | |
| 26 #include "ucnv_bld.h" | |
| 27 #include "ucnv_cnv.h" | |
| 28 #include "cmemory.h" | |
| 29 | |
| 30 /* need to update the offsets when the target moves. */ | |
| 31 /* Note: Recursion may occur in the cb functions, be sure to update the offsets correctly | |
| 32 if you don't use ucnv_cbXXX functions. Make sure you don't use the same callback within | |
| 33 the same call stack if the complexity arises. */ | |
| 34 U_CAPI void U_EXPORT2 | |
| 35 ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args, | |
| 36 const char* source, | |
| 37 int32_t length, | |
| 38 int32_t offsetIndex, | |
| 39 UErrorCode * err) | |
| 40 { | |
| 41 if(U_FAILURE(*err)) { | |
| 42 return; | |
| 43 } | |
| 44 | |
| 45 ucnv_fromUWriteBytes( | |
| 46 args->converter, | |
| 47 source, length, | |
| 48 &args->target, args->targetLimit, | |
| 49 &args->offsets, offsetIndex, | |
| 50 err); | |
| 51 } | |
| 52 | |
| 53 U_CAPI void U_EXPORT2 | |
| 54 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args, | |
| 55 const UChar** source, | |
| 56 const UChar* sourceLimit, | |
| 57 int32_t offsetIndex, | |
| 58 UErrorCode * err) | |
| 59 { | |
| 60 /* | |
| 61 This is a fun one. Recursion can occur - we're basically going to | |
| 62 just retry shoving data through the same converter. Note, if you got | |
| 63 here through some kind of invalid sequence, you maybe should emit a | |
| 64 reset sequence of some kind and/or call ucnv_reset(). Since this | |
| 65 IS an actual conversion, take care that you've changed the callback | |
| 66 or the data, or you'll get an infinite loop. | |
| 67 | |
| 68 Please set the err value to something reasonable before calling | |
| 69 into this. | |
| 70 */ | |
| 71 | |
| 72 char *oldTarget; | |
| 73 | |
| 74 if(U_FAILURE(*err)) | |
| 75 { | |
| 76 return; | |
| 77 } | |
| 78 | |
| 79 oldTarget = args->target; | |
| 80 | |
| 81 ucnv_fromUnicode(args->converter, | |
| 82 &args->target, | |
| 83 args->targetLimit, | |
| 84 source, | |
| 85 sourceLimit, | |
| 86 NULL, /* no offsets */ | |
| 87 FALSE, /* no flush */ | |
| 88 err); | |
| 89 | |
| 90 if(args->offsets) | |
| 91 { | |
| 92 while (args->target != oldTarget) /* if it moved at all.. */ | |
| 93 { | |
| 94 *(args->offsets)++ = offsetIndex; | |
| 95 oldTarget++; | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 /* | |
| 100 Note, if you did something like used a Stop subcallback, things would get interesting. | |
| 101 In fact, here's where we want to return the partially consumed in-source! | |
| 102 */ | |
| 103 if(*err == U_BUFFER_OVERFLOW_ERROR) | |
| 104 /* && (*source < sourceLimit && args->target >= args->targetLimit) | |
| 105 -- S. Hrcek */ | |
| 106 { | |
| 107 /* Overflowed the target. Now, we'll write into the charErrorBuffer. | |
| 108 It's a fixed size. If we overflow it... Hmm */ | |
| 109 char *newTarget; | |
| 110 const char *newTargetLimit; | |
| 111 UErrorCode err2 = U_ZERO_ERROR; | |
| 112 | |
| 113 int8_t errBuffLen; | |
| 114 | |
| 115 errBuffLen = args->converter->charErrorBufferLength; | |
| 116 | |
| 117 /* start the new target at the first free slot in the errbuff.. */ | |
| 118 newTarget = (char *)(args->converter->charErrorBuffer + errBuffLen); | |
| 119 | |
| 120 newTargetLimit = (char *)(args->converter->charErrorBuffer + | |
| 121 sizeof(args->converter->charErrorBuffer)); | |
| 122 | |
| 123 if(newTarget >= newTargetLimit) | |
| 124 { | |
| 125 *err = U_INTERNAL_PROGRAM_ERROR; | |
| 126 return; | |
| 127 } | |
| 128 | |
| 129 /* We're going to tell the converter that the errbuff len is empty. | |
| 130 This prevents the existing errbuff from being 'flushed' out onto | |
| 131 itself. If the errbuff is needed by the converter this time, | |
| 132 we're hosed - we're out of space! */ | |
| 133 | |
| 134 args->converter->charErrorBufferLength = 0; | |
| 135 | |
| 136 ucnv_fromUnicode(args->converter, | |
| 137 &newTarget, | |
| 138 newTargetLimit, | |
| 139 source, | |
| 140 sourceLimit, | |
| 141 NULL, | |
| 142 FALSE, | |
| 143 &err2); | |
| 144 | |
| 145 /* We can go ahead and overwrite the length here. We know just how | |
| 146 to recalculate it. */ | |
| 147 | |
| 148 args->converter->charErrorBufferLength = (int8_t)( | |
| 149 newTarget - (char*)args->converter->charErrorBuffer); | |
| 150 | |
| 151 if((newTarget >= newTargetLimit) || (err2 == U_BUFFER_OVERFLOW_ERROR)) | |
| 152 { | |
| 153 /* now we're REALLY in trouble. | |
| 154 Internal program error - callback shouldn't have written this much | |
| 155 data! | |
| 156 */ | |
| 157 *err = U_INTERNAL_PROGRAM_ERROR; | |
| 158 return; | |
| 159 } | |
| 160 /*else {*/ | |
| 161 /* sub errs could be invalid/truncated/illegal chars or w/e. | |
| 162 These might want to be passed on up.. But the problem is, we already | |
| 163 need to pass U_BUFFER_OVERFLOW_ERROR. That has to override these | |
| 164 other errs.. */ | |
| 165 | |
| 166 /* | |
| 167 if(U_FAILURE(err2)) | |
| 168 ?? | |
| 169 */ | |
| 170 /*}*/ | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 U_CAPI void U_EXPORT2 | |
| 175 ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args, | |
| 176 int32_t offsetIndex, | |
| 177 UErrorCode * err) | |
| 178 { | |
| 179 UConverter *converter; | |
| 180 int32_t length; | |
| 181 | |
| 182 if(U_FAILURE(*err)) { | |
| 183 return; | |
| 184 } | |
| 185 converter = args->converter; | |
| 186 length = converter->subCharLen; | |
| 187 | |
| 188 if(length == 0) { | |
| 189 return; | |
| 190 } | |
| 191 | |
| 192 if(length < 0) { | |
| 193 /* | |
| 194 * Write/convert the substitution string. Its real length is -length. | |
| 195 * Unlike the escape callback, we need not change the converter's | |
| 196 * callback function because ucnv_setSubstString() verified that | |
| 197 * the string can be converted, so we will not get a conversion error | |
| 198 * and will not recurse. | |
| 199 * At worst we should get a U_BUFFER_OVERFLOW_ERROR. | |
| 200 */ | |
| 201 const UChar *source = (const UChar *)converter->subChars; | |
| 202 ucnv_cbFromUWriteUChars(args, &source, source - length, offsetIndex, err); | |
| 203 return; | |
| 204 } | |
| 205 | |
| 206 if(converter->sharedData->impl->writeSub!=NULL) { | |
| 207 converter->sharedData->impl->writeSub(args, offsetIndex, err); | |
| 208 } | |
| 209 else if(converter->subChar1!=0 && (uint16_t)converter->invalidUCharBuffer[0]<=(uint16_t)0xffu) { | |
| 210 /* | |
| 211 TODO: Is this untestable because the MBCS converter has a writeSub function to call | |
| 212 and the other converters don't use subChar1? | |
| 213 */ | |
| 214 ucnv_cbFromUWriteBytes(args, | |
| 215 (const char *)&converter->subChar1, 1, | |
| 216 offsetIndex, err); | |
| 217 } | |
| 218 else { | |
| 219 ucnv_cbFromUWriteBytes(args, | |
| 220 (const char *)converter->subChars, length, | |
| 221 offsetIndex, err); | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 U_CAPI void U_EXPORT2 | |
| 226 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args, | |
| 227 const UChar* source, | |
| 228 int32_t length, | |
| 229 int32_t offsetIndex, | |
| 230 UErrorCode * err) | |
| 231 { | |
| 232 if(U_FAILURE(*err)) { | |
| 233 return; | |
| 234 } | |
| 235 | |
| 236 ucnv_toUWriteUChars( | |
| 237 args->converter, | |
| 238 source, length, | |
| 239 &args->target, args->targetLimit, | |
| 240 &args->offsets, offsetIndex, | |
| 241 err); | |
| 242 } | |
| 243 | |
| 244 U_CAPI void U_EXPORT2 | |
| 245 ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args, | |
| 246 int32_t offsetIndex, | |
| 247 UErrorCode * err) | |
| 248 { | |
| 249 static const UChar kSubstituteChar1 = 0x1A, kSubstituteChar = 0xFFFD; | |
| 250 | |
| 251 /* could optimize this case, just one uchar */ | |
| 252 if(args->converter->invalidCharLength == 1 && args->converter->subChar1 != 0) { | |
| 253 ucnv_cbToUWriteUChars(args, &kSubstituteChar1, 1, offsetIndex, err); | |
| 254 } else { | |
| 255 ucnv_cbToUWriteUChars(args, &kSubstituteChar, 1, offsetIndex, err); | |
| 256 } | |
| 257 } | |
| 258 | |
| 259 #endif |
