source/common/ucnv_err.c

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