Update ICU to 54.1 step 1

source/common/ucnvmbcs.cpp

 /*
 ******************************************************************************
 *
-*   Copyright (C) 2000-2013, International Business Machines
+*   Copyright (C) 2000-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
-*   file name:  ucnvmbcs.c
+*   file name:  ucnvmbcs.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2000jul03
 *   created by: Markus W. Scherer
 *
 *   The current code in this file replaces the previous implementation
 *   of conversion code from multi-byte codepages to Unicode and back.
 *   This implementation supports the following:
@@ skipping 30 matching lines @@
 #include "unicode/udata.h"
 #include "unicode/uset.h"
 #include "unicode/utf8.h"
 #include "unicode/utf16.h"
 #include "ucnv_bld.h"
 #include "ucnvmbcs.h"
 #include "ucnv_ext.h"
 #include "ucnv_cnv.h"
 #include "cmemory.h"
 #include "cstring.h"
-#include "cmutex.h"
+#include "umutex.h"
 
 /* control optimizations according to the platform */
 #define MBCS_UNROLL_SINGLE_TO_BMP 1
 #define MBCS_UNROLL_SINGLE_FROM_BMP 0
 
 /*
  * _MBCSHeader versions 5.3 & 4.3
  * (Note that the _MBCSHeader version is in addition to the converter formatVersion.)
  *
  * This version is optional. Version 5 is used for incompatible data format changes.
@@ skipping 282 matching lines @@
  * In version 3, stage 2 blocks may overlap by multiples of the multiplier
  * for compaction.
  * In version 4, stage 2 blocks (and for single-byte codepages, stage 3 blocks)
  * may overlap by any number of entries.
  *
  * MBCS version 2 added:
  * the converter checks for known output types, which allows
  * adding new ones without crashing an unaware converter
  */
 
-static const UConverterImpl _SBCSUTF8Impl;
-static const UConverterImpl _DBCSUTF8Impl;
+/**
+ * Callback from ucnv_MBCSEnumToUnicode(), takes 32 mappings from
+ * consecutive sequences of bytes, starting from the one encoded in value,
+ * to Unicode code points. (Multiple mappings to reduce per-function call overhead.)
+ * Does not currently support m:n mappings or reverse fallbacks.
+ * This function will not be called for sequences of bytes with leading zeros.
+ *
+ * @param context an opaque pointer, as passed into ucnv_MBCSEnumToUnicode()
+ * @param value contains 1..4 bytes of the first byte sequence, right-aligned
+ * @param codePoints resulting Unicode code points, or negative if a byte sequence does
+ *        not map to anything
+ * @return TRUE to continue enumeration, FALSE to stop
+ */
+typedef UBool U_CALLCONV
+UConverterEnumToUCallback(const void *context, uint32_t value, UChar32 codePoints[32]);
+
+static void
+ucnv_MBCSLoad(UConverterSharedData *sharedData,
+          UConverterLoadArgs *pArgs,
+          const uint8_t *raw,
+          UErrorCode *pErrorCode);
+
+static void
+ucnv_MBCSUnload(UConverterSharedData *sharedData);
+
+static void
+ucnv_MBCSOpen(UConverter *cnv,
+              UConverterLoadArgs *pArgs,
+              UErrorCode *pErrorCode);
+
+static UChar32
+ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
+                  UErrorCode *pErrorCode);
+
+static void
+ucnv_MBCSGetStarters(const UConverter* cnv,
+                 UBool starters[256],
+                 UErrorCode *pErrorCode);
+
+static const char *
+ucnv_MBCSGetName(const UConverter *cnv);
+
+static void
+ucnv_MBCSWriteSub(UConverterFromUnicodeArgs *pArgs,
+              int32_t offsetIndex,
+              UErrorCode *pErrorCode);
+
+static UChar32
+ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
+                  UErrorCode *pErrorCode);
+
+static void
+ucnv_SBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
+                  UConverterToUnicodeArgs *pToUArgs,
+                  UErrorCode *pErrorCode);
+
+static void
+ucnv_MBCSGetUnicodeSet(const UConverter *cnv,
+                   const USetAdder *sa,
+                   UConverterUnicodeSet which,
+                   UErrorCode *pErrorCode);
+
+static void
+ucnv_DBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
+                  UConverterToUnicodeArgs *pToUArgs,
+                  UErrorCode *pErrorCode);
+
+static const UConverterImpl _SBCSUTF8Impl={
+    UCNV_MBCS,
+
+    ucnv_MBCSLoad,
+    ucnv_MBCSUnload,
+
+    ucnv_MBCSOpen,
+    NULL,
+    NULL,
+
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSGetNextUChar,
+
+    ucnv_MBCSGetStarters,
+    ucnv_MBCSGetName,
+    ucnv_MBCSWriteSub,
+    NULL,
+    ucnv_MBCSGetUnicodeSet,
+
+    NULL,
+    ucnv_SBCSFromUTF8
+};
+
+static const UConverterImpl _DBCSUTF8Impl={
+    UCNV_MBCS,
+
+    ucnv_MBCSLoad,
+    ucnv_MBCSUnload,
+
+    ucnv_MBCSOpen,
+    NULL,
+    NULL,
+
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSGetNextUChar,
+
+    ucnv_MBCSGetStarters,
+    ucnv_MBCSGetName,
+    ucnv_MBCSWriteSub,
+    NULL,
+    ucnv_MBCSGetUnicodeSet,
+
+    NULL,
+    ucnv_DBCSFromUTF8
+};
+
+static const UConverterImpl _MBCSImpl={
+    UCNV_MBCS,
+
+    ucnv_MBCSLoad,
+    ucnv_MBCSUnload,
+
+    ucnv_MBCSOpen,
+    NULL,
+    NULL,
+
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSToUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSFromUnicodeWithOffsets,
+    ucnv_MBCSGetNextUChar,
+
+    ucnv_MBCSGetStarters,
+    ucnv_MBCSGetName,
+    ucnv_MBCSWriteSub,
+    NULL,
+    ucnv_MBCSGetUnicodeSet,
+    NULL,
+    NULL
+};
+
+
+/* Static data is in tools/makeconv/ucnvstat.c for data-based
+ * converters. Be sure to update it as well.
+ */
+
+const UConverterSharedData _MBCSData={
+    sizeof(UConverterSharedData), 1,
+    NULL, NULL, NULL, FALSE, &_MBCSImpl, 
+    0, UCNV_MBCS_TABLE_INITIALIZER
+};
+
 
 /* GB 18030 data ------------------------------------------------------------ */
 
 /* helper macros for linear values for GB 18030 four-byte sequences */
 #define LINEAR_18030(a, b, c, d) ((((a)*10+(b))*126L+(c))*10L+(d))
 
 #define LINEAR_18030_BASE LINEAR_18030(0x81, 0x30, 0x81, 0x30)
 
 #define LINEAR(x) LINEAR_18030(x>>24, (x>>16)&0xff, (x>>8)&0xff, x&0xff)
 
@@ skipping 92 matching lines @@
         default:
             /* Should never happen. */
             break;
     }
 
     return SISOLength;
 }
 
 /* Miscellaneous ------------------------------------------------------------ */
 
-/**
- * Callback from ucnv_MBCSEnumToUnicode(), takes 32 mappings from
- * consecutive sequences of bytes, starting from the one encoded in value,
- * to Unicode code points. (Multiple mappings to reduce per-function call overhead.)
- * Does not currently support m:n mappings or reverse fallbacks.
- * This function will not be called for sequences of bytes with leading zeros.
- *
- * @param context an opaque pointer, as passed into ucnv_MBCSEnumToUnicode()
- * @param value contains 1..4 bytes of the first byte sequence, right-aligned
- * @param codePoints resulting Unicode code points, or negative if a byte sequence does
- *        not map to anything
- * @return TRUE to continue enumeration, FALSE to stop
- */
-typedef UBool U_CALLCONV
-UConverterEnumToUCallback(const void *context, uint32_t value, UChar32 codePoints[32]);
-
 /* similar to ucnv_MBCSGetNextUChar() but recursive */
 static UBool
 enumToU(UConverterMBCSTable *mbcsTable, int8_t stateProps[],
         int32_t state, uint32_t offset,
         uint32_t value,
         UConverterEnumToUCallback *callback, const void *context,
         UErrorCode *pErrorCode) {
     UChar32 codePoints[32];
     const int32_t *row;
     const uint16_t *unicodeCodeUnits;
@@ skipping 478 matching lines @@
     ) {
         return 0; /* an extension mapping handled the input */
     }
 
     /* GB 18030 */
     if((cnv->options&_MBCS_OPTION_GB18030)!=0) {
         const uint32_t *range;
         int32_t i;
 
         range=gb18030Ranges[0];
-        for(i=0; i<sizeof(gb18030Ranges)/sizeof(gb18030Ranges[0]); range+=4, ++i) {
+        for(i=0; i<UPRV_LENGTHOF(gb18030Ranges); range+=4, ++i) {
             if(range[0]<=(uint32_t)cp && (uint32_t)cp<=range[1]) {
                 /* found the Unicode code point, output the four-byte sequence for it */
                 uint32_t linear;
                 char bytes[4];
 
                 /* get the linear value of the first GB 18030 code in this range */
                 linear=range[2]-LINEAR_18030_BASE;
 
                 /* add the offset from the beginning of the range */
                 linear+=((uint32_t)cp-range[0]);
@@ skipping 46 matching lines @@
     }
 
     /* GB 18030 */
     if(length==4 && (cnv->options&_MBCS_OPTION_GB18030)!=0) {
         const uint32_t *range;
         uint32_t linear;
         int32_t i;
 
         linear=LINEAR_18030(cnv->toUBytes[0], cnv->toUBytes[1], cnv->toUBytes[2], cnv->toUBytes[3]);
         range=gb18030Ranges[0];
-        for(i=0; i<sizeof(gb18030Ranges)/sizeof(gb18030Ranges[0]); range+=4, ++i) {
+        for(i=0; i<UPRV_LENGTHOF(gb18030Ranges); range+=4, ++i) {
             if(range[2]<=linear && linear<=range[3]) {
                 /* found the sequence, output the Unicode code point for it */
                 *pErrorCode=U_ZERO_ERROR;
 
                 /* add the linear difference between the input and start sequences to the start code point */
                 linear=range[0]+(linear-range[2]);
 
                 /* output this code point */
                 ucnv_toUWriteCodePoint(cnv, linear, target, targetLimit, offsets, sourceIndex, pErrorCode);
 
@@ skipping 299 matching lines @@
     stage2=(uint32_t *)stage1;
 
     /* reconstitute the initial part of stage 2 from the mbcsIndex */
     {
         int32_t stageUTF8Length=((int32_t)mbcsTable->maxFastUChar+1)>>6;
         int32_t stageUTF8Index=0;
         int32_t st1, st2, st3, i;
 
         for(st1=0; stageUTF8Index<stageUTF8Length; ++st1) {
             st2=stage1[st1];
-            if(st2!=stage1Length/2) {
+            if(st2!=(int32_t)stage1Length/2) {
                 /* each stage 2 block has 64 entries corresponding to 16 entries in the mbcsIndex */
                 for(i=0; i<16; ++i) {
                     st3=mbcsTable->mbcsIndex[stageUTF8Index++];
                     if(st3!=0) {
                         /* an stage 2 entry's index is per stage 3 16-block, not per stage 3 entry */
                         st3>>=4;
                         /*
                          * 4 stage 2 entries point to 4 consecutive stage 3 16-blocks which are
                          * allocated together as a single 64-block for access from the mbcsIndex
                          */
@@ skipping 48 matching lines @@
         return;
     }
 
     /* extension data, header version 4.2 and higher */
     offset=header->flags>>8;
     if(offset!=0) {
         mbcsTable->extIndexes=(const int32_t *)(raw+offset);
     }
 
     if(mbcsTable->outputType==MBCS_OUTPUT_EXT_ONLY) {
-        UConverterLoadArgs args={ 0 };
+        UConverterLoadArgs args=UCNV_LOAD_ARGS_INITIALIZER;
         UConverterSharedData *baseSharedData;
         const int32_t *extIndexes;
         const char *baseName;
 
         /* extension-only file, load the base table and set values appropriately */
         if((extIndexes=mbcsTable->extIndexes)==NULL) {
             /* extension-only file without extension */
             *pErrorCode=U_INVALID_TABLE_FORMAT;
             return;
         }
@@ skipping 4015 matching lines @@
     /* write back the updated pointers */
     pToUArgs->source=(char *)source;
     pFromUArgs->target=(char *)target;
 }
 
 /* miscellaneous ------------------------------------------------------------ */
 
 static void
 ucnv_MBCSGetStarters(const UConverter* cnv,
                  UBool starters[256],
-                 UErrorCode *pErrorCode) {
+                 UErrorCode *) {
     const int32_t *state0;
     int i;
 
     state0=cnv->sharedData->mbcs.stateTable[cnv->sharedData->mbcs.dbcsOnlyState];
     for(i=0; i<256; ++i) {
         /* all bytes that cause a state transition from state 0 are lead bytes */
         starters[i]= (UBool)MBCS_ENTRY_IS_TRANSITION(state0[i]);
     }
 }
 
@@ skipping 72 matching lines @@
     if(converter->sharedData->mbcs.countStates==1) {
         return (UConverterType)UCNV_SBCS;
     } else if((converter->sharedData->mbcs.outputType&0xff)==MBCS_OUTPUT_2_SISO) {
         return (UConverterType)UCNV_EBCDIC_STATEFUL;
     } else if(converter->sharedData->staticData->minBytesPerChar==2 && converter->sharedData->staticData->maxBytesPerChar==2) {
         return (UConverterType)UCNV_DBCS;
     }
     return (UConverterType)UCNV_MBCS;
 }
 
-static const UConverterImpl _SBCSUTF8Impl={
-    UCNV_MBCS,
-
-    ucnv_MBCSLoad,
-    ucnv_MBCSUnload,
-
-    ucnv_MBCSOpen,
-    NULL,
-    NULL,
-
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSGetNextUChar,
-
-    ucnv_MBCSGetStarters,
-    ucnv_MBCSGetName,
-    ucnv_MBCSWriteSub,
-    NULL,
-    ucnv_MBCSGetUnicodeSet,
-
-    NULL,
-    ucnv_SBCSFromUTF8
-};
-
-static const UConverterImpl _DBCSUTF8Impl={
-    UCNV_MBCS,
-
-    ucnv_MBCSLoad,
-    ucnv_MBCSUnload,
-
-    ucnv_MBCSOpen,
-    NULL,
-    NULL,
-
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSGetNextUChar,
-
-    ucnv_MBCSGetStarters,
-    ucnv_MBCSGetName,
-    ucnv_MBCSWriteSub,
-    NULL,
-    ucnv_MBCSGetUnicodeSet,
-
-    NULL,
-    ucnv_DBCSFromUTF8
-};
-
-static const UConverterImpl _MBCSImpl={
-    UCNV_MBCS,
-
-    ucnv_MBCSLoad,
-    ucnv_MBCSUnload,
-
-    ucnv_MBCSOpen,
-    NULL,
-    NULL,
-
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSToUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSFromUnicodeWithOffsets,
-    ucnv_MBCSGetNextUChar,
-
-    ucnv_MBCSGetStarters,
-    ucnv_MBCSGetName,
-    ucnv_MBCSWriteSub,
-    NULL,
-    ucnv_MBCSGetUnicodeSet
-};
-
-
-/* Static data is in tools/makeconv/ucnvstat.c for data-based
- * converters. Be sure to update it as well.
- */
-
-const UConverterSharedData _MBCSData={
-    sizeof(UConverterSharedData), 1,
-    NULL, NULL, NULL, FALSE, &_MBCSImpl, 
-    0
-};
-
 #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */