The Tor Browser / file comparison
comparison: intl/icu/source/common/ucnv_err.c
intl/icu/source/common/ucnv_err.c
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:35c90d2263a0 |
|---|---|
| 1 /* | |
| 2 ***************************************************************************** | |
| 3 * | |
| 4 * Copyright (C) 1998-2007, International Business Machines | |
| 5 * Corporation and others. All Rights Reserved. | |
| 6 * | |
| 7 ***************************************************************************** | |
| 8 * | |
| 9 * ucnv_err.c | |
| 10 * Implements error behaviour functions called by T_UConverter_{from,to}Unicode | |
| 11 * | |
| 12 * | |
| 13 * Change history: | |
| 14 * | |
| 15 * 06/29/2000 helena Major rewrite of the callback APIs. | |
| 16 */ | |
| 17 | |
| 18 #include "unicode/utypes.h" | |
| 19 | |
| 20 #if !UCONFIG_NO_CONVERSION | |
| 21 | |
| 22 #include "unicode/ucnv_err.h" | |
| 23 #include "unicode/ucnv_cb.h" | |
| 24 #include "ucnv_cnv.h" | |
| 25 #include "cmemory.h" | |
| 26 #include "unicode/ucnv.h" | |
| 27 #include "ustrfmt.h" | |
| 28 | |
| 29 #define VALUE_STRING_LENGTH 32 | |
| 30 /*Magic # 32 = 4(number of char in value string) * 8(max number of bytes per char for any converter) */ | |
| 31 #define UNICODE_PERCENT_SIGN_CODEPOINT 0x0025 | |
| 32 #define UNICODE_U_CODEPOINT 0x0055 | |
| 33 #define UNICODE_X_CODEPOINT 0x0058 | |
| 34 #define UNICODE_RS_CODEPOINT 0x005C | |
| 35 #define UNICODE_U_LOW_CODEPOINT 0x0075 | |
| 36 #define UNICODE_X_LOW_CODEPOINT 0x0078 | |
| 37 #define UNICODE_AMP_CODEPOINT 0x0026 | |
| 38 #define UNICODE_HASH_CODEPOINT 0x0023 | |
| 39 #define UNICODE_SEMICOLON_CODEPOINT 0x003B | |
| 40 #define UNICODE_PLUS_CODEPOINT 0x002B | |
| 41 #define UNICODE_LEFT_CURLY_CODEPOINT 0x007B | |
| 42 #define UNICODE_RIGHT_CURLY_CODEPOINT 0x007D | |
| 43 #define UNICODE_SPACE_CODEPOINT 0x0020 | |
| 44 #define UCNV_PRV_ESCAPE_ICU 0 | |
| 45 #define UCNV_PRV_ESCAPE_C 'C' | |
| 46 #define UCNV_PRV_ESCAPE_XML_DEC 'D' | |
| 47 #define UCNV_PRV_ESCAPE_XML_HEX 'X' | |
| 48 #define UCNV_PRV_ESCAPE_JAVA 'J' | |
| 49 #define UCNV_PRV_ESCAPE_UNICODE 'U' | |
| 50 #define UCNV_PRV_ESCAPE_CSS2 'S' | |
| 51 #define UCNV_PRV_STOP_ON_ILLEGAL 'i' | |
| 52 | |
| 53 /*Function Pointer STOPS at the ILLEGAL_SEQUENCE */ | |
| 54 U_CAPI void U_EXPORT2 | |
| 55 UCNV_FROM_U_CALLBACK_STOP ( | |
| 56 const void *context, | |
| 57 UConverterFromUnicodeArgs *fromUArgs, | |
| 58 const UChar* codeUnits, | |
| 59 int32_t length, | |
| 60 UChar32 codePoint, | |
| 61 UConverterCallbackReason reason, | |
| 62 UErrorCode * err) | |
| 63 { | |
| 64 /* the caller must have set the error code accordingly */ | |
| 65 return; | |
| 66 } | |
| 67 | |
| 68 | |
| 69 /*Function Pointer STOPS at the ILLEGAL_SEQUENCE */ | |
| 70 U_CAPI void U_EXPORT2 | |
| 71 UCNV_TO_U_CALLBACK_STOP ( | |
| 72 const void *context, | |
| 73 UConverterToUnicodeArgs *toUArgs, | |
| 74 const char* codePoints, | |
| 75 int32_t length, | |
| 76 UConverterCallbackReason reason, | |
| 77 UErrorCode * err) | |
| 78 { | |
| 79 /* the caller must have set the error code accordingly */ | |
| 80 return; | |
| 81 } | |
| 82 | |
| 83 U_CAPI void U_EXPORT2 | |
| 84 UCNV_FROM_U_CALLBACK_SKIP ( | |
| 85 const void *context, | |
| 86 UConverterFromUnicodeArgs *fromUArgs, | |
| 87 const UChar* codeUnits, | |
| 88 int32_t length, | |
| 89 UChar32 codePoint, | |
| 90 UConverterCallbackReason reason, | |
| 91 UErrorCode * err) | |
| 92 { | |
| 93 if (reason <= UCNV_IRREGULAR) | |
| 94 { | |
| 95 if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED)) | |
| 96 { | |
| 97 *err = U_ZERO_ERROR; | |
| 98 } | |
| 99 /* else the caller must have set the error code accordingly. */ | |
| 100 } | |
| 101 /* else ignore the reset, close and clone calls. */ | |
| 102 } | |
| 103 | |
| 104 U_CAPI void U_EXPORT2 | |
| 105 UCNV_FROM_U_CALLBACK_SUBSTITUTE ( | |
| 106 const void *context, | |
| 107 UConverterFromUnicodeArgs *fromArgs, | |
| 108 const UChar* codeUnits, | |
| 109 int32_t length, | |
| 110 UChar32 codePoint, | |
| 111 UConverterCallbackReason reason, | |
| 112 UErrorCode * err) | |
| 113 { | |
| 114 if (reason <= UCNV_IRREGULAR) | |
| 115 { | |
| 116 if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED)) | |
| 117 { | |
| 118 *err = U_ZERO_ERROR; | |
| 119 ucnv_cbFromUWriteSub(fromArgs, 0, err); | |
| 120 } | |
| 121 /* else the caller must have set the error code accordingly. */ | |
| 122 } | |
| 123 /* else ignore the reset, close and clone calls. */ | |
| 124 } | |
| 125 | |
| 126 /*uses uprv_itou to get a unicode escape sequence of the offensive sequence, | |
| 127 *uses a clean copy (resetted) of the converter, to convert that unicode | |
| 128 *escape sequence to the target codepage (if conversion failure happens then | |
| 129 *we revert to substituting with subchar) | |
| 130 */ | |
| 131 U_CAPI void U_EXPORT2 | |
| 132 UCNV_FROM_U_CALLBACK_ESCAPE ( | |
| 133 const void *context, | |
| 134 UConverterFromUnicodeArgs *fromArgs, | |
| 135 const UChar *codeUnits, | |
| 136 int32_t length, | |
| 137 UChar32 codePoint, | |
| 138 UConverterCallbackReason reason, | |
| 139 UErrorCode * err) | |
| 140 { | |
| 141 | |
| 142 UChar valueString[VALUE_STRING_LENGTH]; | |
| 143 int32_t valueStringLength = 0; | |
| 144 int32_t i = 0; | |
| 145 | |
| 146 const UChar *myValueSource = NULL; | |
| 147 UErrorCode err2 = U_ZERO_ERROR; | |
| 148 UConverterFromUCallback original = NULL; | |
| 149 const void *originalContext; | |
| 150 | |
| 151 UConverterFromUCallback ignoredCallback = NULL; | |
| 152 const void *ignoredContext; | |
| 153 | |
| 154 if (reason > UCNV_IRREGULAR) | |
| 155 { | |
| 156 return; | |
| 157 } | |
| 158 | |
| 159 ucnv_setFromUCallBack (fromArgs->converter, | |
| 160 (UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE, | |
| 161 NULL, | |
| 162 &original, | |
| 163 &originalContext, | |
| 164 &err2); | |
| 165 | |
| 166 if (U_FAILURE (err2)) | |
| 167 { | |
| 168 *err = err2; | |
| 169 return; | |
| 170 } | |
| 171 if(context==NULL) | |
| 172 { | |
| 173 while (i < length) | |
| 174 { | |
| 175 valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */ | |
| 176 valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */ | |
| 177 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4); | |
| 178 } | |
| 179 } | |
| 180 else | |
| 181 { | |
| 182 switch(*((char*)context)) | |
| 183 { | |
| 184 case UCNV_PRV_ESCAPE_JAVA: | |
| 185 while (i < length) | |
| 186 { | |
| 187 valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */ | |
| 188 valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */ | |
| 189 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4); | |
| 190 } | |
| 191 break; | |
| 192 | |
| 193 case UCNV_PRV_ESCAPE_C: | |
| 194 valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */ | |
| 195 | |
| 196 if(length==2){ | |
| 197 valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */ | |
| 198 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 8); | |
| 199 | |
| 200 } | |
| 201 else{ | |
| 202 valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */ | |
| 203 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4); | |
| 204 } | |
| 205 break; | |
| 206 | |
| 207 case UCNV_PRV_ESCAPE_XML_DEC: | |
| 208 | |
| 209 valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */ | |
| 210 valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */ | |
| 211 if(length==2){ | |
| 212 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 10, 0); | |
| 213 } | |
| 214 else{ | |
| 215 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 10, 0); | |
| 216 } | |
| 217 valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */ | |
| 218 break; | |
| 219 | |
| 220 case UCNV_PRV_ESCAPE_XML_HEX: | |
| 221 | |
| 222 valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */ | |
| 223 valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */ | |
| 224 valueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */ | |
| 225 if(length==2){ | |
| 226 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0); | |
| 227 } | |
| 228 else{ | |
| 229 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 0); | |
| 230 } | |
| 231 valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */ | |
| 232 break; | |
| 233 | |
| 234 case UCNV_PRV_ESCAPE_UNICODE: | |
| 235 valueString[valueStringLength++] = (UChar) UNICODE_LEFT_CURLY_CODEPOINT; /* adding { */ | |
| 236 valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */ | |
| 237 valueString[valueStringLength++] = (UChar) UNICODE_PLUS_CODEPOINT; /* adding + */ | |
| 238 if (length == 2) { | |
| 239 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 4); | |
| 240 } else { | |
| 241 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4); | |
| 242 } | |
| 243 valueString[valueStringLength++] = (UChar) UNICODE_RIGHT_CURLY_CODEPOINT; /* adding } */ | |
| 244 break; | |
| 245 | |
| 246 case UCNV_PRV_ESCAPE_CSS2: | |
| 247 valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */ | |
| 248 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0); | |
| 249 /* Always add space character, becase the next character might be whitespace, | |
| 250 which would erroneously be considered the termination of the escape sequence. */ | |
| 251 valueString[valueStringLength++] = (UChar) UNICODE_SPACE_CODEPOINT; | |
| 252 break; | |
| 253 | |
| 254 default: | |
| 255 while (i < length) | |
| 256 { | |
| 257 valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */ | |
| 258 valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */ | |
| 259 valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4); | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 myValueSource = valueString; | |
| 264 | |
| 265 /* reset the error */ | |
| 266 *err = U_ZERO_ERROR; | |
| 267 | |
| 268 ucnv_cbFromUWriteUChars(fromArgs, &myValueSource, myValueSource+valueStringLength, 0, err); | |
| 269 | |
| 270 ucnv_setFromUCallBack (fromArgs->converter, | |
| 271 original, | |
| 272 originalContext, | |
| 273 &ignoredCallback, | |
| 274 &ignoredContext, | |
| 275 &err2); | |
| 276 if (U_FAILURE (err2)) | |
| 277 { | |
| 278 *err = err2; | |
| 279 return; | |
| 280 } | |
| 281 | |
| 282 return; | |
| 283 } | |
| 284 | |
| 285 | |
| 286 | |
| 287 U_CAPI void U_EXPORT2 | |
| 288 UCNV_TO_U_CALLBACK_SKIP ( | |
| 289 const void *context, | |
| 290 UConverterToUnicodeArgs *toArgs, | |
| 291 const char* codeUnits, | |
| 292 int32_t length, | |
| 293 UConverterCallbackReason reason, | |
| 294 UErrorCode * err) | |
| 295 { | |
| 296 if (reason <= UCNV_IRREGULAR) | |
| 297 { | |
| 298 if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED)) | |
| 299 { | |
| 300 *err = U_ZERO_ERROR; | |
| 301 } | |
| 302 /* else the caller must have set the error code accordingly. */ | |
| 303 } | |
| 304 /* else ignore the reset, close and clone calls. */ | |
| 305 } | |
| 306 | |
| 307 U_CAPI void U_EXPORT2 | |
| 308 UCNV_TO_U_CALLBACK_SUBSTITUTE ( | |
| 309 const void *context, | |
| 310 UConverterToUnicodeArgs *toArgs, | |
| 311 const char* codeUnits, | |
| 312 int32_t length, | |
| 313 UConverterCallbackReason reason, | |
| 314 UErrorCode * err) | |
| 315 { | |
| 316 if (reason <= UCNV_IRREGULAR) | |
| 317 { | |
| 318 if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED)) | |
| 319 { | |
| 320 *err = U_ZERO_ERROR; | |
| 321 ucnv_cbToUWriteSub(toArgs,0,err); | |
| 322 } | |
| 323 /* else the caller must have set the error code accordingly. */ | |
| 324 } | |
| 325 /* else ignore the reset, close and clone calls. */ | |
| 326 } | |
| 327 | |
| 328 /*uses uprv_itou to get a unicode escape sequence of the offensive sequence, | |
| 329 *and uses that as the substitution sequence | |
| 330 */ | |
| 331 U_CAPI void U_EXPORT2 | |
| 332 UCNV_TO_U_CALLBACK_ESCAPE ( | |
| 333 const void *context, | |
| 334 UConverterToUnicodeArgs *toArgs, | |
| 335 const char* codeUnits, | |
| 336 int32_t length, | |
| 337 UConverterCallbackReason reason, | |
| 338 UErrorCode * err) | |
| 339 { | |
| 340 UChar uniValueString[VALUE_STRING_LENGTH]; | |
| 341 int32_t valueStringLength = 0; | |
| 342 int32_t i = 0; | |
| 343 | |
| 344 if (reason > UCNV_IRREGULAR) | |
| 345 { | |
| 346 return; | |
| 347 } | |
| 348 | |
| 349 if(context==NULL) | |
| 350 { | |
| 351 while (i < length) | |
| 352 { | |
| 353 uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */ | |
| 354 uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT; /* adding X */ | |
| 355 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2); | |
| 356 } | |
| 357 } | |
| 358 else | |
| 359 { | |
| 360 switch(*((char*)context)) | |
| 361 { | |
| 362 case UCNV_PRV_ESCAPE_XML_DEC: | |
| 363 while (i < length) | |
| 364 { | |
| 365 uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */ | |
| 366 uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */ | |
| 367 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 10, 0); | |
| 368 uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */ | |
| 369 } | |
| 370 break; | |
| 371 | |
| 372 case UCNV_PRV_ESCAPE_XML_HEX: | |
| 373 while (i < length) | |
| 374 { | |
| 375 uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */ | |
| 376 uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */ | |
| 377 uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */ | |
| 378 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 0); | |
| 379 uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */ | |
| 380 } | |
| 381 break; | |
| 382 case UCNV_PRV_ESCAPE_C: | |
| 383 while (i < length) | |
| 384 { | |
| 385 uniValueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */ | |
| 386 uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */ | |
| 387 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 2); | |
| 388 } | |
| 389 break; | |
| 390 default: | |
| 391 while (i < length) | |
| 392 { | |
| 393 uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */ | |
| 394 uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT; /* adding X */ | |
| 395 uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2); | |
| 396 valueStringLength += 2; | |
| 397 } | |
| 398 } | |
| 399 } | |
| 400 /* reset the error */ | |
| 401 *err = U_ZERO_ERROR; | |
| 402 | |
| 403 ucnv_cbToUWriteUChars(toArgs, uniValueString, valueStringLength, 0, err); | |
| 404 } | |
| 405 | |
| 406 #endif |
