icuSources/common/ucnv_err.c

   1 /*
   2  *****************************************************************************
   3  *
   4  *   Copyright (C) 1998-2016, 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 48
  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 /*
  54  * IS_DEFAULT_IGNORABLE_CODE_POINT
  55  * This is to check if a code point has the default ignorable unicode property.
  56  * As such, this list needs to be updated if the ignorable code point list ever
  57  * changes.
  58  * To avoid dependency on other code, this list is hard coded here.
  59  * When an ignorable code point is found and is unmappable, the default callbacks
  60  * will ignore them.
  61  * For a list of the default ignorable code points, use this link: http://unicode.org/cldr/utility/list-unicodeset.jsp?a=[%3ADI%3A]&g=
  62  *
  63  * This list should be sync with the one in CharsetCallback.java
  64  */
  65 #define IS_DEFAULT_IGNORABLE_CODE_POINT(c) (\
  66     (c == 0x00AD) || \
  67     (c == 0x034F) || \
  68     (c == 0x061C) || \
  69     (c == 0x115F) || \
  70     (c == 0x1160) || \
  71     (0x17B4 <= c && c <= 0x17B5) || \
  72     (0x180B <= c && c <= 0x180E) || \
  73     (0x200B <= c && c <= 0x200F) || \
  74     (0x202A <= c && c <= 0x202E) || \
  75     (c == 0x2060) || \
  76     (0x2066 <= c && c <= 0x2069) || \
  77     (0x2061 <= c && c <= 0x2064) || \
  78     (0x206A <= c && c <= 0x206F) || \
  79     (c == 0x3164) || \
  80     (0x0FE00 <= c && c <= 0x0FE0F) || \
  81     (c == 0x0FEFF) || \
  82     (c == 0x0FFA0) || \
  83     (0x01BCA0  <= c && c <= 0x01BCA3) || \
  84     (0x01D173 <= c && c <= 0x01D17A) || \
  85     (c == 0x0E0001) || \
  86     (0x0E0020 <= c && c <= 0x0E007F) || \
  87     (0x0E0100 <= c && c <= 0x0E01EF) || \
  88     (c == 0x2065) || \
  89     (0x0FFF0 <= c && c <= 0x0FFF8) || \
  90     (c == 0x0E0000) || \
  91     (0x0E0002 <= c && c <= 0x0E001F) || \
  92     (0x0E0080 <= c && c <= 0x0E00FF) || \
  93     (0x0E01F0 <= c && c <= 0x0E0FFF) \
  94     )
  95
  96
  97 /*Function Pointer STOPS at the ILLEGAL_SEQUENCE */
  98 U_CAPI void    U_EXPORT2
  99 UCNV_FROM_U_CALLBACK_STOP (
 100                   const void *context,
 101                   UConverterFromUnicodeArgs *fromUArgs,
 102                   const UChar* codeUnits,
 103                   int32_t length,
 104                   UChar32 codePoint,
 105                   UConverterCallbackReason reason,
 106                   UErrorCode * err)
 107 {
 108     if (reason == UCNV_UNASSIGNED && IS_DEFAULT_IGNORABLE_CODE_POINT(codePoint))
 109     {
 110         /*
 111          * Skip if the codepoint has unicode property of default ignorable.
 112          */
 113         *err = U_ZERO_ERROR;
 114     }
 115     /* the caller must have set the error code accordingly */
 116     return;
 117 }
 118
 119
 120 /*Function Pointer STOPS at the ILLEGAL_SEQUENCE */
 121 U_CAPI void    U_EXPORT2
 122 UCNV_TO_U_CALLBACK_STOP (
 123                    const void *context,
 124                    UConverterToUnicodeArgs *toUArgs,
 125                    const char* codePoints,
 126                    int32_t length,
 127                    UConverterCallbackReason reason,
 128                    UErrorCode * err)
 129 {
 130     /* the caller must have set the error code accordingly */
 131     return;
 132 }
 133
 134 U_CAPI void    U_EXPORT2
 135 UCNV_FROM_U_CALLBACK_SKIP (
 136                   const void *context,
 137                   UConverterFromUnicodeArgs *fromUArgs,
 138                   const UChar* codeUnits,
 139                   int32_t length,
 140                   UChar32 codePoint,
 141                   UConverterCallbackReason reason,
 142                   UErrorCode * err)
 143 {
 144     if (reason <= UCNV_IRREGULAR)
 145     {
 146         if (reason == UCNV_UNASSIGNED && IS_DEFAULT_IGNORABLE_CODE_POINT(codePoint))
 147         {
 148             /*
 149              * Skip if the codepoint has unicode property of default ignorable.
 150              */
 151             *err = U_ZERO_ERROR;
 152         }
 153         else if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED))
 154         {
 155             *err = U_ZERO_ERROR;
 156         }
 157         /* else the caller must have set the error code accordingly. */
 158     }
 159     /* else ignore the reset, close and clone calls. */
 160 }
 161
 162 U_CAPI void    U_EXPORT2
 163 UCNV_FROM_U_CALLBACK_SUBSTITUTE (
 164                   const void *context,
 165                   UConverterFromUnicodeArgs *fromArgs,
 166                   const UChar* codeUnits,
 167                   int32_t length,
 168                   UChar32 codePoint,
 169                   UConverterCallbackReason reason,
 170                   UErrorCode * err)
 171 {
 172     if (reason <= UCNV_IRREGULAR)
 173     {
 174         if (reason == UCNV_UNASSIGNED && IS_DEFAULT_IGNORABLE_CODE_POINT(codePoint))
 175         {
 176             /*
 177              * Skip if the codepoint has unicode property of default ignorable.
 178              */
 179             *err = U_ZERO_ERROR;
 180         }
 181         else if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED))
 182         {
 183             *err = U_ZERO_ERROR;
 184             ucnv_cbFromUWriteSub(fromArgs, 0, err);
 185         }
 186         /* else the caller must have set the error code accordingly. */
 187     }
 188     /* else ignore the reset, close and clone calls. */
 189 }
 190
 191 /*uses uprv_itou to get a unicode escape sequence of the offensive sequence,
 192  *uses a clean copy (resetted) of the converter, to convert that unicode
 193  *escape sequence to the target codepage (if conversion failure happens then
 194  *we revert to substituting with subchar)
 195  */
 196 U_CAPI void    U_EXPORT2
 197 UCNV_FROM_U_CALLBACK_ESCAPE (
 198                          const void *context,
 199                          UConverterFromUnicodeArgs *fromArgs,
 200                          const UChar *codeUnits,
 201                          int32_t length,
 202                          UChar32 codePoint,
 203                          UConverterCallbackReason reason,
 204                          UErrorCode * err)
 205 {
 206
 207   UChar valueString[VALUE_STRING_LENGTH];
 208   int32_t valueStringLength = 0;
 209   int32_t i = 0;
 210
 211   const UChar *myValueSource = NULL;
 212   UErrorCode err2 = U_ZERO_ERROR;
 213   UConverterFromUCallback original = NULL;
 214   const void *originalContext;
 215
 216   UConverterFromUCallback ignoredCallback = NULL;
 217   const void *ignoredContext;
 218
 219   if (reason > UCNV_IRREGULAR)
 220   {
 221       return;
 222   }
 223   else if (reason == UCNV_UNASSIGNED && IS_DEFAULT_IGNORABLE_CODE_POINT(codePoint))
 224   {
 225       /*
 226        * Skip if the codepoint has unicode property of default ignorable.
 227        */
 228       *err = U_ZERO_ERROR;
 229       return;
 230   }
 231
 232   ucnv_setFromUCallBack (fromArgs->converter,
 233                      (UConverterFromUCallback) UCNV_FROM_U_CALLBACK_SUBSTITUTE,
 234                      NULL,
 235                      &original,
 236                      &originalContext,
 237                      &err2);
 238
 239   if (U_FAILURE (err2))
 240   {
 241     *err = err2;
 242     return;
 243   }
 244   if(context==NULL)
 245   {
 246       while (i < length)
 247       {
 248         valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT;  /* adding % */
 249         valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
 250         valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
 251       }
 252   }
 253   else
 254   {
 255       switch(*((char*)context))
 256       {
 257       case UCNV_PRV_ESCAPE_JAVA:
 258           while (i < length)
 259           {
 260               valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT;    /* adding \ */
 261               valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */
 262               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
 263           }
 264           break;
 265
 266       case UCNV_PRV_ESCAPE_C:
 267           valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT;    /* adding \ */
 268
 269           if(length==2){
 270               valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
 271               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 8);
 272
 273           }
 274           else{
 275               valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */
 276               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4);
 277           }
 278           break;
 279
 280       case UCNV_PRV_ESCAPE_XML_DEC:
 281
 282           valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT;   /* adding & */
 283           valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT;  /* adding # */
 284           if(length==2){
 285               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 10, 0);
 286           }
 287           else{
 288               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 10, 0);
 289           }
 290           valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
 291           break;
 292
 293       case UCNV_PRV_ESCAPE_XML_HEX:
 294
 295           valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT;   /* adding & */
 296           valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT;  /* adding # */
 297           valueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
 298           if(length==2){
 299               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0);
 300           }
 301           else{
 302               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 0);
 303           }
 304           valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
 305           break;
 306
 307       case UCNV_PRV_ESCAPE_UNICODE:
 308           valueString[valueStringLength++] = (UChar) UNICODE_LEFT_CURLY_CODEPOINT;    /* adding { */
 309           valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT;    /* adding U */
 310           valueString[valueStringLength++] = (UChar) UNICODE_PLUS_CODEPOINT; /* adding + */
 311           if (length == 2) {
 312               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 4);
 313           } else {
 314               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4);
 315           }
 316           valueString[valueStringLength++] = (UChar) UNICODE_RIGHT_CURLY_CODEPOINT;    /* adding } */
 317           break;
 318
 319       case UCNV_PRV_ESCAPE_CSS2:
 320           valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT;    /* adding \ */
 321           valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0);
 322           /* Always add space character, becase the next character might be whitespace,
 323              which would erroneously be considered the termination of the escape sequence. */
 324           valueString[valueStringLength++] = (UChar) UNICODE_SPACE_CODEPOINT;
 325           break;
 326
 327       default:
 328           while (i < length)
 329           {
 330               valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT;  /* adding % */
 331               valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT;             /* adding U */
 332               valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
 333           }
 334       }
 335   }
 336   myValueSource = valueString;
 337
 338   /* reset the error */
 339   *err = U_ZERO_ERROR;
 340
 341   ucnv_cbFromUWriteUChars(fromArgs, &myValueSource, myValueSource+valueStringLength, 0, err);
 342
 343   ucnv_setFromUCallBack (fromArgs->converter,
 344                          original,
 345                          originalContext,
 346                          &ignoredCallback,
 347                          &ignoredContext,
 348                          &err2);
 349   if (U_FAILURE (err2))
 350   {
 351       *err = err2;
 352       return;
 353   }
 354
 355   return;
 356 }
 357
 358
 359
 360 U_CAPI void  U_EXPORT2
 361 UCNV_TO_U_CALLBACK_SKIP (
 362                  const void *context,
 363                  UConverterToUnicodeArgs *toArgs,
 364                  const char* codeUnits,
 365                  int32_t length,
 366                  UConverterCallbackReason reason,
 367                  UErrorCode * err)
 368 {
 369     if (reason <= UCNV_IRREGULAR)
 370     {
 371         if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED))
 372         {
 373             *err = U_ZERO_ERROR;
 374         }
 375         /* else the caller must have set the error code accordingly. */
 376     }
 377     /* else ignore the reset, close and clone calls. */
 378 }
 379
 380 U_CAPI void    U_EXPORT2
 381 UCNV_TO_U_CALLBACK_SUBSTITUTE (
 382                  const void *context,
 383                  UConverterToUnicodeArgs *toArgs,
 384                  const char* codeUnits,
 385                  int32_t length,
 386                  UConverterCallbackReason reason,
 387                  UErrorCode * err)
 388 {
 389     if (reason <= UCNV_IRREGULAR)
 390     {
 391         if (context == NULL || (*((char*)context) == UCNV_PRV_STOP_ON_ILLEGAL && reason == UCNV_UNASSIGNED))
 392         {
 393             *err = U_ZERO_ERROR;
 394             ucnv_cbToUWriteSub(toArgs,0,err);
 395         }
 396         /* else the caller must have set the error code accordingly. */
 397     }
 398     /* else ignore the reset, close and clone calls. */
 399 }
 400
 401 /*uses uprv_itou to get a unicode escape sequence of the offensive sequence,
 402  *and uses that as the substitution sequence
 403  */
 404 U_CAPI void   U_EXPORT2
 405 UCNV_TO_U_CALLBACK_ESCAPE (
 406                  const void *context,
 407                  UConverterToUnicodeArgs *toArgs,
 408                  const char* codeUnits,
 409                  int32_t length,
 410                  UConverterCallbackReason reason,
 411                  UErrorCode * err)
 412 {
 413     UChar uniValueString[VALUE_STRING_LENGTH];
 414     int32_t valueStringLength = 0;
 415     int32_t i = 0;
 416
 417     if (reason > UCNV_IRREGULAR)
 418     {
 419         return;
 420     }
 421
 422     if(context==NULL)
 423     {
 424         while (i < length)
 425         {
 426             uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
 427             uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT;    /* adding X */
 428             valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2);
 429         }
 430     }
 431     else
 432     {
 433         switch(*((char*)context))
 434         {
 435         case UCNV_PRV_ESCAPE_XML_DEC:
 436             while (i < length)
 437             {
 438                 uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT;   /* adding & */
 439                 uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT;  /* adding # */
 440                 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 10, 0);
 441                 uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
 442             }
 443             break;
 444
 445         case UCNV_PRV_ESCAPE_XML_HEX:
 446             while (i < length)
 447             {
 448                 uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT;   /* adding & */
 449                 uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT;  /* adding # */
 450                 uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
 451                 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 0);
 452                 uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
 453             }
 454             break;
 455         case UCNV_PRV_ESCAPE_C:
 456             while (i < length)
 457             {
 458                 uniValueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT;    /* adding \ */
 459                 uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
 460                 valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 2);
 461             }
 462             break;
 463         default:
 464             while (i < length)
 465             {
 466                 uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
 467                 uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT;    /* adding X */
 468                 uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2);
 469                 valueStringLength += 2;
 470             }
 471         }
 472     }
 473     /* reset the error */
 474     *err = U_ZERO_ERROR;
 475
 476     ucnv_cbToUWriteUChars(toArgs, uniValueString, valueStringLength, 0, err);
 477 }
 478
 479 #endif