Update uconv.patch to exactly match upstream SVN r37045.

source/common/ucnv2022.cpp

 /*
 **********************************************************************
-*   Copyright (C) 2000-2014, International Business Machines
+*   Copyright (C) 2000-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   file name:  ucnv2022.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2000feb03
 *   created by: Markus W. Scherer
 *
@@ skipping 54 matching lines @@
  *    This means, for example, that when ISO-8859-7 is designated, the following
  *    ISO-2022 bytes 00..7f should be interpreted as ISO-8859-7 bytes 80..ff.
  *    The ICU ISO-2022 converter does not handle this - and has no information
  *    about which subconverter would have to be shifted vs. which is designed
  *    for 7-bit ISO-2022.
  *
  * Markus Scherer 2003-dec-03
  */
 #endif
 
+#if !UCONFIG_ONLY_HTML_CONVERSION
 static const char SHIFT_IN_STR[]  = "\x0F";
 // static const char SHIFT_OUT_STR[] = "\x0E";
+#endif
 
 #define CR      0x0D
 #define LF      0x0A
 #define H_TAB   0x09
 #define V_TAB   0x0B
 #define SPACE   0x20
 
 enum {
     HWKANA_START=0xff61,
     HWKANA_END=0xff9f
@@ skipping 55 matching lines @@
         CNS_11643_1,
         CNS_11643_2,
         CNS_11643_3,
         CNS_11643_4,
         CNS_11643_5,
         CNS_11643_6,
         CNS_11643_7
 } StateEnum;
 
 /* is the StateEnum charset value for a DBCS charset? */
-#if UCONFIG_NO_NON_HTML5_CONVERSION
+#if UCONFIG_ONLY_HTML_CONVERSION
 #define IS_JP_DBCS(cs) (JISX208==(cs))
 #else
 #define IS_JP_DBCS(cs) (JISX208<=(cs) && (cs)<=KSC5601)
 #endif
 
 #define CSM(cs) ((uint16_t)1<<(cs))
 
 /*
  * Each of these charset masks (with index x) contains a bit for a charset in exact correspondence
  * to whether that charset is used in the corresponding version x of ISO_2022,locale=ja,version=x
  *
  * Note: The converter uses some leniency:
  * - The escape sequence ESC ( I for half-width 7-bit Katakana is recognized in
  *   all versions, not just JIS7 and JIS8.
  * - ICU does not distinguish between different versions of JIS X 0208.
  */
-#if UCONFIG_NO_NON_HTML5_CONVERSION
+#if UCONFIG_ONLY_HTML_CONVERSION
 enum { MAX_JA_VERSION=0 };
 #else
 enum { MAX_JA_VERSION=4 };
 #endif
 static const uint16_t jpCharsetMasks[MAX_JA_VERSION+1]={
-/* 
- * TODO(jshin): The encoding spec has JISX212, but we don't support it.
- * See https://www.w3.org/Bugs/Public/show_bug.cgi?id=26885
- */
     CSM(ASCII)|CSM(JISX201)|CSM(JISX208)|CSM(HWKANA_7BIT),
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
     CSM(ASCII)|CSM(JISX201)|CSM(JISX208)|CSM(HWKANA_7BIT)|CSM(JISX212),
     CSM(ASCII)|CSM(JISX201)|CSM(JISX208)|CSM(HWKANA_7BIT)|CSM(JISX212)|CSM(GB2312)|CSM(KSC5601)|CSM(ISO8859_1)|CSM(ISO8859_7),
     CSM(ASCII)|CSM(JISX201)|CSM(JISX208)|CSM(HWKANA_7BIT)|CSM(JISX212)|CSM(GB2312)|CSM(KSC5601)|CSM(ISO8859_1)|CSM(ISO8859_7),
     CSM(ASCII)|CSM(JISX201)|CSM(JISX208)|CSM(HWKANA_7BIT)|CSM(JISX212)|CSM(GB2312)|CSM(KSC5601)|CSM(ISO8859_1)|CSM(ISO8859_7)
 #endif
 };
 
 typedef enum {
         ASCII1=0,
         LATIN1,
@@ skipping 176 matching lines @@
     ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022
     ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_NON_TERMINAL_2022    ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022
     ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022
 };
 
 /* Type def for refactoring changeState_2022 code*/
 typedef enum{
 #ifdef U_ENABLE_GENERIC_ISO_2022
     ISO_2022=0,
 #endif
-#if UCONFIG_NO_NON_HTML5_CONVERSION
-    ISO_2022_JP=1
-#else
     ISO_2022_JP=1,
+#if !UCONFIG_ONLY_HTML_CONVERSION
     ISO_2022_KR=2,
     ISO_2022_CN=3
 #endif
 } Variant2022;
 
 /*********** ISO 2022 Converter Protos ***********/
 static void
 _ISO2022Open(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode);
 
 static void
@@ skipping 13 matching lines @@
 
 #ifdef U_ENABLE_GENERIC_ISO_2022
 static void
 T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverterToUnicodeArgs* args, UErrorCode* err);
 #endif
 
 namespace {
 
 /*const UConverterSharedData _ISO2022Data;*/
 extern const UConverterSharedData _ISO2022JPData;
+
+#if !UCONFIG_ONLY_HTML_CONVERSION
 extern const UConverterSharedData _ISO2022KRData;
 extern const UConverterSharedData _ISO2022CNData;
+#endif
 
 }  // namespace
 
 /*************** Converter implementations ******************/
 
 /* The purpose of this function is to get around gcc compiler warnings. */
 static inline void
 fromUWriteUInt8(UConverter *cnv,
                  const char *bytes, int32_t length,
                  uint8_t **target, const char *targetLimit,
@@ skipping 64 matching lines @@
         myConverterData->version = version;
         if(myLocale[0]=='j' && (myLocale[1]=='a'|| myLocale[1]=='p') &&
             (myLocale[2]=='_' || myLocale[2]=='\0'))
         {
             size_t len=0;
             /* open the required converters and cache them */
             if(version>MAX_JA_VERSION) {
                 /* prevent indexing beyond jpCharsetMasks[] */
                 myConverterData->version = version = 0;
             }
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
             if(jpCharsetMasks[version]&CSM(ISO8859_7)) {
                 myConverterData->myConverterArray[ISO8859_7] =
                     ucnv_loadSharedData("ISO8859_7", &stackPieces, &stackArgs, errorCode);
             }
-#endif
             myConverterData->myConverterArray[JISX208] =
                 ucnv_loadSharedData("Shift-JIS", &stackPieces, &stackArgs, errorCode);
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
             if(jpCharsetMasks[version]&CSM(JISX212)) {
                 myConverterData->myConverterArray[JISX212] =
                     ucnv_loadSharedData("jisx-212", &stackPieces, &stackArgs, errorCode);
             }
             if(jpCharsetMasks[version]&CSM(GB2312)) {
                 myConverterData->myConverterArray[GB2312] =
                     ucnv_loadSharedData("ibm-5478", &stackPieces, &stackArgs, errorCode);   /* gb_2312_80-1 */
             }
             if(jpCharsetMasks[version]&CSM(KSC5601)) {
                 myConverterData->myConverterArray[KSC5601] =
                     ucnv_loadSharedData("ksc_5601", &stackPieces, &stackArgs, errorCode);
             }
-#endif
 
             /* set the function pointers to appropriate funtions */
             cnv->sharedData=(UConverterSharedData*)(&_ISO2022JPData);
             uprv_strcpy(myConverterData->locale,"ja");
 
             (void)uprv_strcpy(myConverterData->name,"ISO_2022,locale=ja,version=");
             len = uprv_strlen(myConverterData->name);
             myConverterData->name[len]=(char)(myConverterData->version+(int)'0');
             myConverterData->name[len+1]='\0';
         }
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
         else if(myLocale[0]=='k' && (myLocale[1]=='o'|| myLocale[1]=='r') &&
             (myLocale[2]=='_' || myLocale[2]=='\0'))
         {
             const char *cnvName;
             if(version==1) {
                 cnvName="icu-internal-25546";
             } else {
                 cnvName="ibm-949";
                 myConverterData->version=version=0;
             }
@@ skipping 49 matching lines @@
                 myConverterData->version = 0;
                 (void)uprv_strcpy(myConverterData->name,"ISO_2022,locale=zh,version=0");
             }else if (version==1){
                 myConverterData->version = 1;
                 (void)uprv_strcpy(myConverterData->name,"ISO_2022,locale=zh,version=1");
             }else {
                 myConverterData->version = 2;
                 (void)uprv_strcpy(myConverterData->name,"ISO_2022,locale=zh,version=2");
             }
         }
-#endif // !UCONFIG_NO_NON_HTML5_CONVERSION
+#endif  // !UCONFIG_ONLY_HTML_CONVERSION
         else{
 #ifdef U_ENABLE_GENERIC_ISO_2022
             myConverterData->isFirstBuffer = TRUE;
 
             /* append the UTF-8 escape sequence */
             cnv->charErrorBufferLength = 3;
             cnv->charErrorBuffer[0] = 0x1b;
             cnv->charErrorBuffer[1] = 0x25;
             cnv->charErrorBuffer[2] = 0x42;
 
@@ skipping 114 matching lines @@
     INVALID_STATE   ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,SS2_STATE      ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,ASCII          ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,JISX201        ,HWKANA_7BIT    ,JISX201        ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,JISX208        ,GB2312         ,JISX208        ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,ISO8859_1      ,ISO8859_7      ,JISX208        ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,KSC5601        ,JISX212        ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
 };
 
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
 /*************** to unicode *******************/
 static const int8_t nextStateToUnicodeCN[MAX_STATES_2022]= {
 /*      0                1               2               3               4               5               6               7               8               9    */
      INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,SS2_STATE      ,SS3_STATE      ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,GB2312_1       ,INVALID_STATE  ,ISO_IR_165
     ,CNS_11643_1    ,CNS_11643_2    ,CNS_11643_3    ,CNS_11643_4    ,CNS_11643_5    ,CNS_11643_6    ,CNS_11643_7    ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
@@ skipping 145 matching lines @@
                         if(myData2022->toU2022State.g<2) {
                             myData2022->toU2022State.prevG=myData2022->toU2022State.g;
                         }
                         myData2022->toU2022State.g=2;
                     } else {
                         /* illegal to have SS2 before a matching designator */
                         *err = U_ILLEGAL_ESCAPE_SEQUENCE;
                     }
                     break;
                 /* case SS3_STATE: not used in ISO-2022-JP-x */
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                 case ISO8859_1:
                 case ISO8859_7:
                     if((jpCharsetMasks[myData2022->version] & CSM(tempState)) == 0) {
                         *err = U_UNSUPPORTED_ESCAPE_SEQUENCE;
                     } else {
                         /* G2 charset for SS2 */
                         myData2022->toU2022State.cs[2]=(int8_t)tempState;
                     }
                     break;
-#endif
                 default:
                     if((jpCharsetMasks[myData2022->version] & CSM(tempState)) == 0) {
                         *err = U_UNSUPPORTED_ESCAPE_SEQUENCE;
                     } else {
                         /* G0 charset */
                         myData2022->toU2022State.cs[0]=(int8_t)tempState;
                     }
                     break;
                 }
             }
             break;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
         case ISO_2022_CN:
             {
                 StateEnum tempState=(StateEnum)nextStateToUnicodeCN[offset];
                 switch(tempState) {
                 case INVALID_STATE:
                     *err = U_UNSUPPORTED_ESCAPE_SEQUENCE;
                     break;
                 case SS2_STATE:
                     if(myData2022->toU2022State.cs[2]!=0) {
                         if(myData2022->toU2022State.g<2) {
@@ skipping 41 matching lines @@
                 }
             }
             break;
         case ISO_2022_KR:
             if(offset==0x30){
                 /* nothing to be done, just accept this one escape sequence */
             } else {
                 *err = U_UNSUPPORTED_ESCAPE_SEQUENCE;
             }
             break;
-#endif /* #if !UCONFIG_NO_NON_HTML5_CONVERSION */
+#endif  // !UCONFIG_ONLY_HTML_CONVERSION
 
         default:
             *err = U_ILLEGAL_ESCAPE_SEQUENCE;
             break;
         }
     }
     if(U_SUCCESS(*err)) {
         _this->toULength = 0;
     } else if(*err==U_ILLEGAL_ESCAPE_SEQUENCE) {
         if(_this->toULength>1) {
@@ skipping 22 matching lines @@
                 uprv_memcpy(_this->preToU, _this->toUBytes+1, -_this->preToULength);
                 *source-=bytesFromThisBuffer;
             }
             _this->toULength=1;
         }
     } else if(*err==U_UNSUPPORTED_ESCAPE_SEQUENCE) {
         _this->toUCallbackReason = UCNV_UNASSIGNED;
     }
 }
 
+#if !UCONFIG_ONLY_HTML_CONVERSION
 /*Checks the characters of the buffer against valid 2022 escape sequences
 *if the match we return a pointer to the initial start of the sequence otherwise
 *we return sourceLimit
 */
 /*for 2022 looks ahead in the stream
  *to determine the longest possible convertible
  *data stream
  */
 static inline const char*
 getEndOfBuffer_2022(const char** source,
@@ skipping 34 matching lines @@
     }while (++mySource < sourceLimit);
 
     return sourceLimit;
 #else
     while(mySource < sourceLimit && *mySource != ESC_2022) {
         ++mySource;
     }
     return mySource;
 #endif
 }
-
+#endif
 
 /* This inline function replicates code in _MBCSFromUChar32() function in ucnvmbcs.c
  * any future change in _MBCSFromUChar32() function should be reflected here.
  * @return number of bytes in *value; negative number if fallback; 0 if no mapping
  */
 static inline int32_t
 MBCS_FROM_UCHAR32_ISO2022(UConverterSharedData* sharedData,
                                          UChar32 c,
                                          uint32_t* value,
                                          UBool useFallback,
@@ skipping 303 matching lines @@
 *          KSC5601 : alias to ibm-949 mapping table
 *          GB2312 : alias to ibm-1386 mapping table
 *          ISO-8859-1 : Algorithmic implemented as LATIN1 case
 *          ISO-8859-7 : alisas to ibm-9409 mapping table
 */
 
 /* preference order of JP charsets */
 static const StateEnum jpCharsetPref[]={
     ASCII,
     JISX201,
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
     ISO8859_1,
     ISO8859_7,
-#endif
     JISX208,
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
     JISX212,
     GB2312,
     KSC5601,
-#endif
     HWKANA_7BIT
 };
 
 /*
  * The escape sequences must be in order of the enum constants like JISX201  = 3,
  * not in order of jpCharsetPref[]!
  */
 static const char escSeqChars[][6] ={
     "\x1B\x28\x42",         /* <ESC>(B  ASCII       */
     "\x1B\x2E\x41",         /* <ESC>.A  ISO-8859-1  */
@@ skipping 349 matching lines @@
                 int8_t cs0 = choices[i];
                 switch(cs0) {
                 case ASCII:
                     if(sourceChar <= 0x7f) {
                         targetValue = (uint32_t)sourceChar;
                         len = 1;
                         cs = cs0;
                         g = 0;
                     }
                     break;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                 case ISO8859_1:
                     if(GR96_START <= sourceChar && sourceChar <= GR96_END) {
                         targetValue = (uint32_t)sourceChar - 0x80;
                         len = 1;
                         cs = cs0;
                         g = 2;
                     }
                     break;
-#endif
                 case HWKANA_7BIT:
                     if((uint32_t)(sourceChar - HWKANA_START) <= (HWKANA_END - HWKANA_START)) {
                         if(converterData->version==3) {
                             /* JIS7: use G1 (SO) */
                             /* Shift U+FF61..U+FF9F to bytes 21..5F. */
                             targetValue = (uint32_t)(sourceChar - (HWKANA_START - 0x21));
                             len = 1;
                             pFromU2022State->cs[1] = cs = cs0; /* do not output an escape sequence */
                             g = 1;
                         } else if(converterData->version==4) {
@@ skipping 41 matching lines @@
                         }
                     } else if(len == 0 && useFallback &&
                               (uint32_t)(sourceChar - HWKANA_START) <= (HWKANA_END - HWKANA_START)) {
                         targetValue = hwkana_fb[sourceChar - HWKANA_START];
                         len = -2;
                         cs = cs0;
                         g = 0;
                         useFallback = FALSE;
                     }
                     break;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                 case ISO8859_7:
                     /* G0 SBCS forced to 7-bit output */
                     len2 = MBCS_SINGLE_FROM_UCHAR32(
                                 converterData->myConverterArray[cs0],
                                 sourceChar, &value,
                                 useFallback);
                     if(len2 != 0 && !(len2 < 0 && len != 0) && GR96_START <= value && value <= GR96_END) {
                         targetValue = value - 0x80;
                         len = len2;
                         cs = cs0;
                         g = 2;
                         useFallback = FALSE;
                     }
                     break;
-#endif
                 default:
                     /* G0 DBCS */
                     len2 = MBCS_FROM_UCHAR32_ISO2022(
                                 converterData->myConverterArray[cs0],
                                 sourceChar, &value,
                                 useFallback, MBCS_OUTPUT_2);
                     if(len2 == 2 || (len2 == -2 && len == 0)) {  /* only accept DBCS: abs(len)==2 */
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                         if(cs0 == KSC5601) {
                             /*
                              * Check for valid bytes for the encoding scheme.
                              * This is necessary because the sub-converter (windows-949)
                              * has a broader encoding scheme than is valid for 2022.
                              */
                             value = _2022FromGR94DBCS(value);
                             if(value == 0) {
                                 break;
                             }
                         }
-#endif
                         targetValue = value;
                         len = len2;
                         cs = cs0;
                         g = 0;
                         useFallback = FALSE;
                     }
                     break;
                 }
             }
 
@@ skipping 273 matching lines @@
                     /* return from a single-shift state to the previous one */
                     if(pToU2022State->g >= 2) {
                         pToU2022State->g=pToU2022State->prevG;
                     }
                 } else switch(cs) {
                 case ASCII:
                     if(mySourceChar <= 0x7f) {
                         targetUniChar = mySourceChar;
                     }
                     break;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                 case ISO8859_1:
                     if(mySourceChar <= 0x7f) {
                         targetUniChar = mySourceChar + 0x80;
                     }
                     /* return from a single-shift state to the previous one */
                     pToU2022State->g=pToU2022State->prevG;
                     break;
                 case ISO8859_7:
                     if(mySourceChar <= 0x7f) {
                         /* convert mySourceChar+0x80 to use a normal 8-bit table */
                         targetUniChar =
                             _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP(
                                 myData->myConverterArray[cs],
                                 mySourceChar + 0x80);
                     }
                     /* return from a single-shift state to the previous one */
                     pToU2022State->g=pToU2022State->prevG;
                     break;
-#endif
                 case JISX201:
                     if(mySourceChar <= 0x7f) {
                         targetUniChar = jisx201ToU(mySourceChar);
                     }
                     break;
                 case HWKANA_7BIT:
                     if((uint8_t)(mySourceChar - 0x21) <= (0x5f - 0x21)) {
                         /* 7-bit halfwidth Katakana */
                         targetUniChar = mySourceChar + (HWKANA_START - 0x21);
                     }
@@ skipping 19 matching lines @@
                         trailIsOk = (uint8_t)(trailByte - 0x21) <= (0x7e - 0x21);
                         if (leadIsOk && trailIsOk) {
                             ++mySource;
                             tmpSourceChar = (mySourceChar << 8) | trailByte;
                             if(cs == JISX208) {
                                 _2022ToSJIS((uint8_t)mySourceChar, trailByte, tempBuf);
                                 mySourceChar = tmpSourceChar;
                             } else {
                                 /* Copy before we modify tmpSourceChar so toUnicodeCallback() sees the correct bytes. */
                                 mySourceChar = tmpSourceChar;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
                                 if (cs == KSC5601) {
                                     tmpSourceChar += 0x8080;  /* = _2022ToGR94DBCS(tmpSourceChar) */
                                 }
-#endif
                                 tempBuf[0] = (char)(tmpSourceChar >> 8);
                                 tempBuf[1] = (char)(tmpSourceChar);
                             }
                             targetUniChar = ucnv_MBCSSimpleGetNextUChar(myData->myConverterArray[cs], tempBuf, 2, FALSE);
                         } else if (!(trailIsOk || IS_2022_CONTROL(trailByte))) {
                             /* report a pair of illegal bytes if the second byte is not a DBCS starter */
                             ++mySource;
                             /* add another bit so that the code below writes 2 bytes in case of error */
                             mySourceChar = 0x10000 | (mySourceChar << 8) | trailByte;
                         }
@@ skipping 41 matching lines @@
             *err =U_BUFFER_OVERFLOW_ERROR;
             break;
         }
     }
 endloop:
     args->target = myTarget;
     args->source = mySource;
 }
 
 
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
 /***************************************************************
 *   Rules for ISO-2022-KR encoding
 *   i) The KSC5601 designator sequence should appear only once in a file,
 *      at the begining of a line before any KSC5601 characters. This usually
 *      means that it appears by itself on the first line of the file
 *  ii) There are only 2 shifting sequences SO to shift into double byte mode
 *      and SI to shift into single byte mode
 */
 static void
 UConverter_fromUnicode_ISO_2022_KR_OFFSETS_LOGIC_IBM(UConverterFromUnicodeArgs* args, UErrorCode* err){
@@ skipping 1123 matching lines @@
         }
         else{
             *err =U_BUFFER_OVERFLOW_ERROR;
             break;
         }
     }
 endloop:
     args->target = myTarget;
     args->source = mySource;
 }
-#endif /* #if !UCONFIG_NO_NON_HTML5_CONVERSION */
+#endif /* #if !UCONFIG_ONLY_HTML_CONVERSION */
 
 static void
 _ISO_2022_WriteSub(UConverterFromUnicodeArgs *args, int32_t offsetIndex, UErrorCode *err) {
     UConverter *cnv = args->converter;
     UConverterDataISO2022 *myConverterData=(UConverterDataISO2022 *) cnv->extraInfo;
     ISO2022State *pFromU2022State=&myConverterData->fromU2022State;
     char *p, *subchar;
     char buffer[8];
     int32_t length;
 
@@ skipping 181 matching lines @@
 #endif
 
     cnvData = (UConverterDataISO2022*)cnv->extraInfo;
 
     /* open a set and initialize it with code points that are algorithmically round-tripped */
     switch(cnvData->locale[0]){
     case 'j':
         /* include JIS X 0201 which is hardcoded */
         sa->add(sa->set, 0xa5);
         sa->add(sa->set, 0x203e);
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
         if(jpCharsetMasks[cnvData->version]&CSM(ISO8859_1)) {
             /* include Latin-1 for some variants of JP */
             sa->addRange(sa->set, 0, 0xff);
         } else {
             /* include ASCII for JP */
             sa->addRange(sa->set, 0, 0x7f);
         }
-#else
-        /* include ASCII for JP */
-        sa->addRange(sa->set, 0, 0x7f);
-#endif
         if(cnvData->version==3 || cnvData->version==4 || which==UCNV_ROUNDTRIP_AND_FALLBACK_SET) {
             /*
              * Do not test (jpCharsetMasks[cnvData->version]&CSM(HWKANA_7BIT))!=0
              * because the bit is on for all JP versions although only versions 3 & 4 (JIS7 & JIS8)
              * use half-width Katakana.
              * This is because all ISO-2022-JP variants are lenient in that they accept (in toUnicode)
              * half-width Katakana via the ESC ( I sequence.
              * However, we only emit (fromUnicode) half-width Katakana according to the
              * definition of each variant.
              *
              * When including fallbacks,
              * we need to include half-width Katakana Unicode code points for all JP variants because
              * JIS X 0208 has hardcoded fallbacks for them (which map to full-width Katakana).
              */
             /* include half-width Katakana for JP */
             sa->addRange(sa->set, HWKANA_START, HWKANA_END);
         }
         break;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
     case 'c':
     case 'z':
         /* include ASCII for CN */
         sa->addRange(sa->set, 0, 0x7f);
         break;
     case 'k':
         /* there is only one converter for KR, and it is not in the myConverterArray[] */
         cnvData->currentConverter->sharedData->impl->getUnicodeSet(
                 cnvData->currentConverter, sa, which, pErrorCode);
         /* the loop over myConverterArray[] will simply not find another converter */
@@ skipping 18 matching lines @@
 
     for (i=0; i<UCNV_2022_MAX_CONVERTERS; i++) {
         UConverterSetFilter filter;
         if(cnvData->myConverterArray[i]!=NULL) {
             if(cnvData->locale[0]=='j' && i==JISX208) {
                 /*
                  * Only add code points that map to Shift-JIS codes
                  * corresponding to JIS X 0208.
                  */
                 filter=UCNV_SET_FILTER_SJIS;
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
             } else if( (cnvData->locale[0]=='c' || cnvData->locale[0]=='z') &&
                        cnvData->version==0 && i==CNS_11643) {
                 /*
                  * Version-specific for CN:
                  * CN version 0 does not map CNS planes 3..7 although
                  * they are all available in the CNS conversion table;
                  * CN version 1 (-EXT) does map them all.
                  * The two versions create different Unicode sets.
                  */
                 filter=UCNV_SET_FILTER_2022_CN;
@@ skipping 118 matching lines @@
     { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
 };
 
 namespace {
 
 const UConverterSharedData _ISO2022JPData=
         UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_ISO2022JPStaticData, &_ISO2022JPImpl);
 
 }  // namespace
 
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
+#if !UCONFIG_ONLY_HTML_CONVERSION
 /************* KR ***************/
 static const UConverterImpl _ISO2022KRImpl={
     UCNV_ISO_2022,
 
     NULL,
     NULL,
 
     _ISO2022Open,
     _ISO2022Close,
     _ISO2022Reset,
@@ skipping 80 matching lines @@
     0,
     { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
 };
 
 namespace {
 
 const UConverterSharedData _ISO2022CNData=
         UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_ISO2022CNStaticData, &_ISO2022CNImpl);
 
 }  // namespace
-#endif /* #if !UCONFIG_NO_NON_HTML5_CONVERSION */
+#endif /* #if !UCONFIG_ONLY_HTML_CONVERSION */
 
 #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */