Update ICU to 54.1 step 1

source/common/ucnv2022.cpp

 /*
 **********************************************************************
-*   Copyright (C) 2000-2012, International Business Machines
+*   Copyright (C) 2000-2014, 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 22 matching lines @@
 #include "unicode/ucnv_cb.h"
 #include "unicode/utf16.h"
 #include "ucnv_imp.h"
 #include "ucnv_bld.h"
 #include "ucnv_cnv.h"
 #include "ucnvmbcs.h"
 #include "cstring.h"
 #include "cmemory.h"
 #include "uassert.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 #ifdef U_ENABLE_GENERIC_ISO_2022
 /*
  * I am disabling the generic ISO-2022 converter after proposing to do so on
  * the icu mailing list two days ago.
  *
  * Reasons:
  * 1. It does not fully support the ISO-2022/ECMA-35 specification with all of
  *    its designation sequences, single shifts with return to the previous state,
  *    switch-with-no-return to UTF-16BE or similar, etc.
  *    This is unlike the language-specific variants like ISO-2022-JP which
@@ skipping 89 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
-#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
-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
     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,
         SBCS,
         DBCS,
         MBCS,
         HWKANA
 }Cnv2022Type;
@@ skipping 166 matching lines @@
      VALID_NON_TERMINAL_2022    ,VALID_NON_TERMINAL_2022    ,VALID_NON_TERMINAL_2022    ,VALID_NON_TERMINAL_2022     ,VALID_NON_TERMINAL_2022   ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022        ,VALID_NON_TERMINAL_2022    ,VALID_TERMINAL_2022        ,VALID_TERMINAL_2022
     ,VALID_MAYBE_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_NON_TERMINAL_2022    ,VALID_NON_TERMINAL_2022    ,VALID_NON_TERMINAL_2022    ,VALID_NON_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        ,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_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,
     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
  _ISO2022Close(UConverter *converter);
 
 static void
@@ skipping 96 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
         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
         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
 /*************** 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
     ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE  ,INVALID_STATE
 };
-#endif
 
 
 static UCNV_TableStates_2022
 getKey_2022(char c,int32_t* key,int32_t* offset){
     int32_t togo;
     int32_t low = 0;
     int32_t hi = MAX_STATES_2022;
     int32_t oldmid=0;
 
     togo = normalize_esq_chars_2022[(uint8_t)c];
     if(togo == 0) {
         /* not a valid character anywhere in an escape sequence */
         *key = 0;
         *offset = 0;
         return INVALID_2022;
     }
     togo = (*key << 5) + togo;
 
     while (hi != low)  /*binary search*/{
 
-        register int32_t mid = (hi+low) >> 1; /*Finds median*/
+        int32_t mid = (hi+low) >> 1; /*Finds median*/
 
         if (mid == oldmid)
             break;
 
         if (escSeqStateTable_Key_2022[mid] > togo){
             hi = mid;
         }
         else if (escSeqStateTable_Key_2022[mid] < togo){
             low = mid;
         }
@@ skipping 111 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
         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 */
 
         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 400 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 312 matching lines @@
                 choices[choiceCount++] = cs = pFromU2022State->cs[0];
                 csm &= ~CSM(cs);
 
                 /* try the current G2 charset */
                 if((cs = pFromU2022State->cs[2]) != 0) {
                     choices[choiceCount++] = cs;
                     csm &= ~CSM(cs);
                 }
 
                 /* try all the other possible charsets */
-                for(i = 0; i < LENGTHOF(jpCharsetPref); ++i) {
+                for(i = 0; i < UPRV_LENGTHOF(jpCharsetPref); ++i) {
                     cs = (int8_t)jpCharsetPref[i];
                     if(CSM(cs) & csm) {
                         choices[choiceCount++] = cs;
                         csm &= ~CSM(cs);
                     }
                 }
             }
 
             cs = g = 0;
             /*
@@ skipping 16 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
 /***************************************************************
 *   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 */
 
 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
     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 */
         break;
-#endif
     default:
         break;
     }
 
 #if 0  /* Replaced by ucnv_MBCSGetFilteredUnicodeSetForUnicode() until we implement ucnv_getUnicodeSet() with reverse fallbacks. */
             if( (cnvData->locale[0]=='c' || cnvData->locale[0]=='z') &&
                 cnvData->version==0 && i==CNS_11643
             ) {
                 /* special handling for non-EXT ISO-2022-CN: add only code points for CNS planes 1 and 2 */
                 ucnv_MBCSGetUnicodeSetForBytes(
                         cnvData->myConverterArray[i],
                         sa, UCNV_ROUNDTRIP_SET,
                         0, 0x81, 0x82,
                         pErrorCode);
             }
 #endif
 
     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
-            } else if( (cnvData->locale[0]=='c' || cnvData->locale[0]=='z') &&
-                       cnvData->version==0 && i==CNS_11643) {
+            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;
+            } else 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;
             } else if(i==KSC5601) {
                 /*
                  * Some of the KSC 5601 tables (convrtrs.txt has this aliases on multiple tables)
                  * are broader than GR94.
                  */
                 filter=UCNV_SET_FILTER_GR94DBCS;
-#endif
             } else {
                 filter=UCNV_SET_FILTER_NONE;
             }
             ucnv_MBCSGetFilteredUnicodeSetForUnicode(cnvData->myConverterArray[i], sa, which, filter, pErrorCode);
         }
     }
 
     /*
      * ISO 2022 converters must not convert SO/SI/ESC despite what
      * sub-converters do by themselves.
@@ skipping 117 matching lines @@
     NULL,
     NULL,
     &_ISO2022JPStaticData,
     FALSE,
     &_ISO2022JPImpl,
     0, UCNV_MBCS_TABLE_INITIALIZER
 };
 
 }  // namespace
 
-#if !UCONFIG_NO_NON_HTML5_CONVERSION
 /************* KR ***************/
 static const UConverterImpl _ISO2022KRImpl={
     UCNV_ISO_2022,
 
     NULL,
     NULL,
 
     _ISO2022Open,
     _ISO2022Close,
     _ISO2022Reset,
@@ skipping 96 matching lines @@
     ~((uint32_t) 0),
     NULL,
     NULL,
     &_ISO2022CNStaticData,
     FALSE,
     &_ISO2022CNImpl,
     0, UCNV_MBCS_TABLE_INITIALIZER
 };
 
 }  // namespace
-#endif /* #if !UCONFIG_NO_NON_HTML5_CONVERSION */
 
 #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */