icuSources/common/ucnv_err.c

   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