From 62c59f82c27e88e1fc31d73bc246190da6463b84 Mon Sep 17 00:00:00 2001
From: Eric Mader <emader@svn.icu-project.org>
Date: Fri, 10 Feb 2006 00:10:58 +0000
Subject: [PATCH] ICU-4639 Change class static const arrays to file private
 static const arrays.

X-SVN-Rev: 19127
---
 icu4c/source/i18n/csr2022.cpp |  23 +++----
 icu4c/source/i18n/csr2022.h   |  12 ----
 icu4c/source/i18n/csrmbcs.cpp |  34 ++++-------
 icu4c/source/i18n/csrmbcs.h   |  23 -------
 icu4c/source/i18n/csrsbcs.cpp | 112 +++++++++++++++++-----------------
 icu4c/source/i18n/csrsbcs.h   |  92 ----------------------------
 6 files changed, 76 insertions(+), 220 deletions(-)

diff --git a/icu4c/source/i18n/csr2022.cpp b/icu4c/source/i18n/csr2022.cpp
index 7991c7ae255..a60b43c4dd5 100644
--- a/icu4c/source/i18n/csr2022.cpp
+++ b/icu4c/source/i18n/csr2022.cpp
@@ -13,6 +13,8 @@
 
 U_NAMESPACE_BEGIN
 
+#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
+
 /**
  * Matching function shared among the 2022 detectors JP, CN and KR
  * Counts up the number of legal an unrecognized escape sequences in
@@ -96,7 +98,7 @@ scanInput:
 }
 
 
-const uint8_t CharsetRecog_2022JP::escapeSequences[][5] = {
+static const uint8_t escapeSequences_2022JP[][5] = {
     {0x1b, 0x24, 0x28, 0x43, 0x00},   // KS X 1001:1992
     {0x1b, 0x24, 0x28, 0x44, 0x00},   // JIS X 212-1990
     {0x1b, 0x24, 0x40, 0x00, 0x00},   // JIS C 6226-1978
@@ -111,11 +113,11 @@ const uint8_t CharsetRecog_2022JP::escapeSequences[][5] = {
     {0x1b, 0x2e, 0x46, 0x00, 0x00}    // ISO 8859-7
 };
 
-const uint8_t CharsetRecog_2022KR::escapeSequences[][5] = {
+static const uint8_t escapeSequences_2022KR[][5] = {
     {0x1b, 0x24, 0x29, 0x43, 0x00}   
 };
 
-const uint8_t CharsetRecog_2022CN::escapeSequences[][5] = {
+static const uint8_t escapeSequences_2022CN[][5] = {
     {0x1b, 0x24, 0x29, 0x41, 0x00},   // GB 2312-80
     {0x1b, 0x24, 0x29, 0x47, 0x00},   // CNS 11643-1992 Plane 1
     {0x1b, 0x24, 0x2A, 0x48, 0x00},   // CNS 11643-1992 Plane 2
@@ -129,15 +131,6 @@ const uint8_t CharsetRecog_2022CN::escapeSequences[][5] = {
     {0x1b, 0x4f, 0x00, 0x00, 0x00},   // SS3
 };
 
-const int32_t CharsetRecog_2022JP::escapeSequences_length =
-    sizeof(CharsetRecog_2022JP::escapeSequences) / sizeof(CharsetRecog_2022JP::escapeSequences[0]);
-
-const int32_t CharsetRecog_2022KR::escapeSequences_length =
-    sizeof(CharsetRecog_2022KR::escapeSequences) / sizeof(CharsetRecog_2022KR::escapeSequences[0]);
-
-const int32_t CharsetRecog_2022CN::escapeSequences_length =
-    sizeof(CharsetRecog_2022CN::escapeSequences) / sizeof(CharsetRecog_2022CN::escapeSequences[0]);
-
 const char *CharsetRecog_2022JP::getName() const
 {
     return "ISO-2022-JP";
@@ -145,7 +138,7 @@ const char *CharsetRecog_2022JP::getName() const
 
 int32_t CharsetRecog_2022JP::match(InputText *textIn)
 {
-    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences, escapeSequences_length);
+    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences_2022JP, ARRAY_SIZE(escapeSequences_2022JP));
 }
 
 const char *CharsetRecog_2022KR::getName() const
@@ -155,7 +148,7 @@ const char *CharsetRecog_2022KR::getName() const
 
 int32_t CharsetRecog_2022KR::match(InputText *textIn)
 {
-    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences, escapeSequences_length);
+    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences_2022KR, ARRAY_SIZE(escapeSequences_2022KR));
 }
 
 const char *CharsetRecog_2022CN::getName() const
@@ -165,7 +158,7 @@ const char *CharsetRecog_2022CN::getName() const
 
 int32_t CharsetRecog_2022CN::match(InputText *textIn)
 {
-    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences, escapeSequences_length);
+    return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences_2022CN, ARRAY_SIZE(escapeSequences_2022CN));
 }
 
 CharsetRecog_2022::~CharsetRecog_2022()
diff --git a/icu4c/source/i18n/csr2022.h b/icu4c/source/i18n/csr2022.h
index 98c7c8c154a..ce74f30b63c 100644
--- a/icu4c/source/i18n/csr2022.h
+++ b/icu4c/source/i18n/csr2022.h
@@ -50,10 +50,6 @@ protected:
 
 class CharsetRecog_2022JP :public CharsetRecog_2022
 {
-private:
-    static const uint8_t escapeSequences[][5];
-    static const int32_t escapeSequences_length;
-
 public:        
     virtual ~CharsetRecog_2022JP() {}
 
@@ -63,10 +59,6 @@ public:
 };
 
 class CharsetRecog_2022KR :public CharsetRecog_2022 {
-private:
-    static const uint8_t escapeSequences[][5];
-    static const int32_t escapeSequences_length;
-
 public:       
     virtual ~CharsetRecog_2022KR() {}
 
@@ -78,10 +70,6 @@ public:
 
 class CharsetRecog_2022CN :public CharsetRecog_2022
 {
-private:
-    static const uint8_t escapeSequences[][5];
-    static const int32_t escapeSequences_length;
-
 public:        
     virtual ~CharsetRecog_2022CN() {}
 
diff --git a/icu4c/source/i18n/csrmbcs.cpp b/icu4c/source/i18n/csrmbcs.cpp
index 410e774dafa..8aec7938e3c 100644
--- a/icu4c/source/i18n/csrmbcs.cpp
+++ b/icu4c/source/i18n/csrmbcs.cpp
@@ -13,13 +13,15 @@
 
 U_NAMESPACE_BEGIN
 
-#define min(x,y) ((x<y)?(x):(y))
+#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
 
-const int32_t CharsetRecog_sjis::commonChars []= 
+#define min(x,y) (((x)<(y))?(x):(y))
+
+const int32_t commonChars_sjis [] = {
 // TODO:  This set of data comes from the character frequency-
 //        of-occurence analysis tool.  The data needs to be moved
 //        into a resource and loaded from there.
-{0x82cc, 0x82c5, 0x82a2, 0x815b, 0x8141, 0x82b5, 0x82c9, 0x82b7, 0x8142, 0x82c4, 
+0x82cc, 0x82c5, 0x82a2, 0x815b, 0x8141, 0x82b5, 0x82c9, 0x82b7, 0x8142, 0x82c4, 
 0x82c6, 0x82cd, 0x82dc, 0x82f0, 0x82e9, 0x82c8, 0x82aa, 0x8393, 0x82bd, 0x8358, 
 0x82ea, 0x8343, 0x82a4, 0x82a9, 0x8367, 0x82b1, 0x8145, 0x82e0, 0x838b, 0x834e, 
 0x82e8, 0x82e7, 0x8140, 0x8362, 0x8389, 0x82c1, 0x838a, 0x82ab, 0x8376, 0x82b3, 
@@ -30,7 +32,7 @@ const int32_t CharsetRecog_sjis::commonChars []=
 0x838d, 0x8346, 0x834f, 0x8380, 0x82ed, 0x8d73, 0x8349, 0x8365, 0x8fee, 0x95b6, 
 0x8169, 0x816a, 0x836a, 0x8dec, 0x82bf, 0x834c, 0x8366, 0x82e2, 0x838c, 0x945c};
 
-const int32_t CharsetRecog_euc_jp::commonChars[] = 
+const int32_t commonChars_euc_jp[] = 
 // TODO:  This set of data comes from the character frequency-
 //        of-occurence analysis tool.  The data needs to be moved
 //        into a resource and loaded from there.
@@ -45,7 +47,7 @@ const int32_t CharsetRecog_euc_jp::commonChars[] =
 0xa5ed, 0xa5a7, 0xa5b0, 0xa5e0, 0xa4ef, 0xb9d4, 0xa5aa, 0xa5c6, 0xbef0, 0xcab8, 
 0xa1ca, 0xa1cb, 0xa5cb, 0xbaee, 0xa4c1, 0xa5ad, 0xa5c7, 0xa4e4, 0xa5ec, 0xc7bd};
 
-const int32_t CharsetRecog_euc_kr::commonChars[] = 
+const int32_t commonChars_euc_kr[] = 
 // TODO:  This set of data comes from the character frequency-
 //        of-occurence analysis tool.  The data needs to be moved
 //        into a resource and loaded from there.
@@ -60,7 +62,7 @@ const int32_t CharsetRecog_euc_kr::commonChars[] =
 0xb9ab, 0xc0af, 0xbef8, 0xb5a5, 0xbcd2, 0xb9ce, 0xc1df, 0xbfc0, 0xc1f8, 0xb0e6, 
 0xb1c7, 0xbad0, 0xbefa, 0xc0e5, 0xbec8, 0xc1b6, 0xb8bb, 0xb0f8, 0xb9cc, 0xb0c5};
 
-const int32_t CharsetRecog_gb_18030::commonChars[] = 
+const int32_t commonChars_gb_18030[] = 
 // TODO:  This set of data comes from the character frequency-
 //        of-occurence analysis tool.  The data needs to be moved
 //        into a resource and loaded from there.
@@ -80,18 +82,6 @@ const int32_t CharsetRecog_gb_18030::commonChars[] =
 0xbcd2, 0xcef1, 0xbdab, 0xa3ad, 0xa3bf, 0xb3a4, 0xb9fb, 0xd6ae, 0xc1bf, 0xbbd8, 
 0xb8f1, 0xb6f8, 0xb6a8, 0xcde2, 0xbac3, 0xb3cc, 0xccd8, 0xd7d4, 0xcbb5};
 
-const int32_t CharsetRecog_sjis::commonCharsLen =
-    sizeof(CharsetRecog_sjis::commonChars) / sizeof(CharsetRecog_sjis::commonChars[0]);
-
-const int32_t CharsetRecog_euc_jp::commonCharsLen =
-    sizeof(CharsetRecog_euc_jp::commonChars) / sizeof(CharsetRecog_euc_jp::commonChars[0]);
-
-const int32_t CharsetRecog_euc_kr::commonCharsLen =
-    sizeof(CharsetRecog_euc_kr::commonChars) / sizeof(CharsetRecog_euc_kr::commonChars[0]);
-
-const int32_t CharsetRecog_gb_18030::commonCharsLen =
-    sizeof(CharsetRecog_gb_18030::commonChars) / sizeof(CharsetRecog_gb_18030::commonChars[0]);
-
 static int32_t binarySearch(const int32_t *array, int32_t len, int32_t value)
 {
 #if 0
@@ -275,7 +265,7 @@ UBool CharsetRecog_sjis::nextChar(iteratedChar* it, InputText* det) {
 
 int32_t CharsetRecog_sjis::match(InputText* det)
 {
-    return match_mbcs(det, commonChars, commonCharsLen);
+    return match_mbcs(det, commonChars_sjis, ARRAY_SIZE(commonChars_sjis));
 }
 
 const char *CharsetRecog_sjis::getName() const
@@ -363,7 +353,7 @@ const char *CharsetRecog_euc_jp::getName() const
 
 int32_t CharsetRecog_euc_jp::match(InputText *det)
 {
-    return match_mbcs(det, commonChars, commonCharsLen);
+    return match_mbcs(det, commonChars_euc_jp, ARRAY_SIZE(commonChars_euc_jp));
 }
 
 CharsetRecog_euc_kr::~CharsetRecog_euc_kr()
@@ -378,7 +368,7 @@ const char *CharsetRecog_euc_kr::getName() const
 
 int32_t CharsetRecog_euc_kr::match(InputText *det)
 {
-    return match_mbcs(det, commonChars, commonCharsLen);
+    return match_mbcs(det, commonChars_euc_kr, ARRAY_SIZE(commonChars_euc_kr));
 }
 
 CharsetRecog_gb_18030::~CharsetRecog_gb_18030()
@@ -447,7 +437,7 @@ const char *CharsetRecog_gb_18030::getName() const
 
 int32_t CharsetRecog_gb_18030::match(InputText *det)
 {
-    return match_mbcs(det, commonChars, commonCharsLen);
+    return match_mbcs(det, commonChars_gb_18030, ARRAY_SIZE(commonChars_gb_18030));
 }
 
 U_NAMESPACE_END
diff --git a/icu4c/source/i18n/csrmbcs.h b/icu4c/source/i18n/csrmbcs.h
index 9987031e3aa..d0adf07d123 100644
--- a/icu4c/source/i18n/csrmbcs.h
+++ b/icu4c/source/i18n/csrmbcs.h
@@ -92,10 +92,6 @@ public:
  *
  */
 class CharsetRecog_sjis : public CharsetRecog_mbcs {
-private:
-    static const int32_t commonChars [];
-    static const int32_t commonCharsLen;
-
 public:
     virtual ~CharsetRecog_sjis();
 
@@ -137,10 +133,6 @@ public:
  */
 class CharsetRecog_euc_jp : public CharsetRecog_euc
 {
-private:
-    static const int32_t commonChars[];
-    static const int32_t commonCharsLen;
-
 public:             
     virtual ~CharsetRecog_euc_jp();
 
@@ -155,10 +147,6 @@ public:
  */
 class CharsetRecog_euc_kr : public CharsetRecog_euc
 {
-private:
-    static const int32_t commonChars[];
-    static const int32_t commonCharsLen;
-
 public:
     virtual ~CharsetRecog_euc_kr();
 
@@ -175,17 +163,6 @@ public:
  */
 class CharsetRecog_gb_18030 : public CharsetRecog_mbcs 
 {
-private:
-
-    static const int32_t commonChars[];                 
-    static const int32_t commonCharsLen;
-    /*
-     *  (non-Javadoc)
-     *  Get the next character value for EUC based encodings.
-     *  Character "value" is simply the raw bytes that make up the character
-     *     packed into an int.
-     */
-
 public:
     virtual ~CharsetRecog_gb_18030();
 
diff --git a/icu4c/source/i18n/csrsbcs.cpp b/icu4c/source/i18n/csrsbcs.cpp
index b8319993bdd..e2a479cb811 100644
--- a/icu4c/source/i18n/csrsbcs.cpp
+++ b/icu4c/source/i18n/csrsbcs.cpp
@@ -152,7 +152,7 @@ int32_t CharsetRecog_sbcs::match_sbcs(InputText *det, const int32_t ngrams[],  c
     return result;
 }
 
-const uint8_t CharsetRecog_8859_1::charMap[] = {
+static const uint8_t charMap_8859_1[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -187,7 +187,7 @@ const uint8_t CharsetRecog_8859_1::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 
 };
 
-const uint8_t CharsetRecog_8859_2::charMap[] = {
+static const uint8_t charMap_8859_2[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -222,7 +222,7 @@ const uint8_t CharsetRecog_8859_2::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x20, 
 };
 
-const uint8_t CharsetRecog_8859_5::charMap[] = {
+static const uint8_t charMap_8859_5[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -257,7 +257,7 @@ const uint8_t CharsetRecog_8859_5::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0x20, 0xFE, 0xFF, 
 };
 
-const uint8_t CharsetRecog_8859_6::charMap[] = {
+static const uint8_t charMap_8859_6[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -292,7 +292,7 @@ const uint8_t CharsetRecog_8859_6::charMap[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
 };
 
-const uint8_t CharsetRecog_8859_7::charMap[] = {
+static const uint8_t charMap_8859_7[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -327,7 +327,7 @@ const uint8_t CharsetRecog_8859_7::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0x20, 
 };
 
-const uint8_t CharsetRecog_8859_8::charMap[] = {
+static const uint8_t charMap_8859_8[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -362,7 +362,7 @@ const uint8_t CharsetRecog_8859_8::charMap[] = {
     0xF8, 0xF9, 0xFA, 0x20, 0x20, 0x20, 0x20, 0x20, 
 };
 
-const uint8_t CharsetRecog_8859_9::charMap[] = {
+static const uint8_t charMap_8859_9[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -397,14 +397,14 @@ const uint8_t CharsetRecog_8859_9::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 
 };
 
-const int32_t CharsetRecog_windows_1251::ngrams[] = {
+static const int32_t ngrams_windows_1251[] = {
     0x20E220, 0x20E2EE, 0x20E4EE, 0x20E7E0, 0x20E820, 0x20EAE0, 0x20EAEE, 0x20EDE0, 0x20EDE5, 0x20EEE1, 0x20EFEE, 0x20EFF0, 0x20F0E0, 0x20F1EE, 0x20F1F2, 0x20F2EE, 
     0x20F7F2, 0x20FDF2, 0xE0EDE8, 0xE0F2FC, 0xE3EE20, 0xE5EBFC, 0xE5EDE8, 0xE5F1F2, 0xE5F220, 0xE820EF, 0xE8E520, 0xE8E820, 0xE8FF20, 0xEBE5ED, 0xEBE820, 0xEBFCED, 
     0xEDE020, 0xEDE520, 0xEDE8E5, 0xEDE8FF, 0xEDEE20, 0xEDEEE2, 0xEE20E2, 0xEE20EF, 0xEE20F1, 0xEEE220, 0xEEE2E0, 0xEEE3EE, 0xEEE920, 0xEEEBFC, 0xEEEC20, 0xEEF1F2, 
     0xEFEEEB, 0xEFF0E5, 0xEFF0E8, 0xEFF0EE, 0xF0E0E2, 0xF0E5E4, 0xF1F2E0, 0xF1F2E2, 0xF1F2E8, 0xF1FF20, 0xF2E5EB, 0xF2EE20, 0xF2EEF0, 0xF2FC20, 0xF7F2EE, 0xFBF520, 
 };
 
-const uint8_t CharsetRecog_windows_1251::charMap[] = {
+static const uint8_t charMap_windows_1251[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -439,14 +439,14 @@ const uint8_t CharsetRecog_windows_1251::charMap[] = {
     0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 
 };
 
-const int32_t CharsetRecog_windows_1256::ngrams[] = {
+static const int32_t ngrams_windows_1256[] = {
     0x20C7E1, 0x20C7E4, 0x20C8C7, 0x20DAE1, 0x20DDED, 0x20E1E1, 0x20E3E4, 0x20E6C7, 0xC720C7, 0xC7C120, 0xC7CA20, 0xC7D120, 0xC7E120, 0xC7E1C3, 0xC7E1C7, 0xC7E1C8, 
     0xC7E1CA, 0xC7E1CC, 0xC7E1CD, 0xC7E1CF, 0xC7E1D3, 0xC7E1DA, 0xC7E1DE, 0xC7E1E3, 0xC7E1E6, 0xC7E1ED, 0xC7E320, 0xC7E420, 0xC7E4CA, 0xC820C7, 0xC920C7, 0xC920DD, 
     0xC920E1, 0xC920E3, 0xC920E6, 0xCA20C7, 0xCF20C7, 0xCFC920, 0xD120C7, 0xD1C920, 0xD320C7, 0xDA20C7, 0xDAE1EC, 0xDDED20, 0xE120C7, 0xE1C920, 0xE1EC20, 0xE1ED20, 
     0xE320C7, 0xE3C720, 0xE3C920, 0xE3E420, 0xE420C7, 0xE520C7, 0xE5C720, 0xE6C7E1, 0xE6E420, 0xEC20C7, 0xED20C7, 0xED20E3, 0xED20E6, 0xEDC920, 0xEDD120, 0xEDE420, 
 };
 
-const uint8_t CharsetRecog_windows_1256::charMap[] = {
+static const uint8_t charMap_windows_1256[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -481,14 +481,14 @@ const uint8_t CharsetRecog_windows_1256::charMap[] = {
     0x20, 0xF9, 0x20, 0xFB, 0xFC, 0x20, 0x20, 0xFF, 
 };
 
-const int32_t CharsetRecog_KOI8_R::ngrams[] = {
+static const int32_t ngrams_KOI8_R[] = {
     0x20C4CF, 0x20C920, 0x20CBC1, 0x20CBCF, 0x20CEC1, 0x20CEC5, 0x20CFC2, 0x20D0CF, 0x20D0D2, 0x20D2C1, 0x20D3CF, 0x20D3D4, 0x20D4CF, 0x20D720, 0x20D7CF, 0x20DAC1, 
     0x20DCD4, 0x20DED4, 0xC1CEC9, 0xC1D4D8, 0xC5CCD8, 0xC5CEC9, 0xC5D3D4, 0xC5D420, 0xC7CF20, 0xC920D0, 0xC9C520, 0xC9C920, 0xC9D120, 0xCCC5CE, 0xCCC920, 0xCCD8CE, 
     0xCEC120, 0xCEC520, 0xCEC9C5, 0xCEC9D1, 0xCECF20, 0xCECFD7, 0xCF20D0, 0xCF20D3, 0xCF20D7, 0xCFC7CF, 0xCFCA20, 0xCFCCD8, 0xCFCD20, 0xCFD3D4, 0xCFD720, 0xCFD7C1, 
     0xD0CFCC, 0xD0D2C5, 0xD0D2C9, 0xD0D2CF, 0xD2C1D7, 0xD2C5C4, 0xD3D120, 0xD3D4C1, 0xD3D4C9, 0xD3D4D7, 0xD4C5CC, 0xD4CF20, 0xD4CFD2, 0xD4D820, 0xD9C820, 0xDED4CF, 
 };
 
-const uint8_t CharsetRecog_KOI8_R::charMap[] = {
+static const uint8_t charMap_KOI8_R[] = {
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 
@@ -524,140 +524,140 @@ const uint8_t CharsetRecog_KOI8_R::charMap[] = {
 };
 
 //ISO-8859-1,2,5,6,7,8,9 Ngrams    
-const int32_t CharsetRecog_8859_1_en::ngrams[] = {
+static const int32_t ngrams_8859_1_en[] = {
     0x206120, 0x20616E, 0x206265, 0x20636F, 0x20666F, 0x206861, 0x206865, 0x20696E, 0x206D61, 0x206F66, 0x207072, 0x207265, 0x207361, 0x207374, 0x207468, 0x20746F, 
     0x207768, 0x616964, 0x616C20, 0x616E20, 0x616E64, 0x617320, 0x617420, 0x617465, 0x617469, 0x642061, 0x642074, 0x652061, 0x652073, 0x652074, 0x656420, 0x656E74, 
     0x657220, 0x657320, 0x666F72, 0x686174, 0x686520, 0x686572, 0x696420, 0x696E20, 0x696E67, 0x696F6E, 0x697320, 0x6E2061, 0x6E2074, 0x6E6420, 0x6E6720, 0x6E7420, 
     0x6F6620, 0x6F6E20, 0x6F7220, 0x726520, 0x727320, 0x732061, 0x732074, 0x736169, 0x737420, 0x742074, 0x746572, 0x746861, 0x746865, 0x74696F, 0x746F20, 0x747320, 
 };
 
-const int32_t CharsetRecog_8859_1_da::ngrams[] = {
+static const int32_t ngrams_8859_1_da[] = {
     0x206166, 0x206174, 0x206465, 0x20656E, 0x206572, 0x20666F, 0x206861, 0x206920, 0x206D65, 0x206F67, 0x2070E5, 0x207369, 0x207374, 0x207469, 0x207669, 0x616620, 
     0x616E20, 0x616E64, 0x617220, 0x617420, 0x646520, 0x64656E, 0x646572, 0x646574, 0x652073, 0x656420, 0x656465, 0x656E20, 0x656E64, 0x657220, 0x657265, 0x657320, 
     0x657420, 0x666F72, 0x676520, 0x67656E, 0x676572, 0x696765, 0x696C20, 0x696E67, 0x6B6520, 0x6B6B65, 0x6C6572, 0x6C6967, 0x6C6C65, 0x6D6564, 0x6E6465, 0x6E6520, 
     0x6E6720, 0x6E6765, 0x6F6720, 0x6F6D20, 0x6F7220, 0x70E520, 0x722064, 0x722065, 0x722073, 0x726520, 0x737465, 0x742073, 0x746520, 0x746572, 0x74696C, 0x766572, 
 };
 
-const int32_t CharsetRecog_8859_1_de::ngrams[] = {
+static const int32_t ngrams_8859_1_de[] = {
     0x20616E, 0x206175, 0x206265, 0x206461, 0x206465, 0x206469, 0x206569, 0x206765, 0x206861, 0x20696E, 0x206D69, 0x207363, 0x207365, 0x20756E, 0x207665, 0x20766F, 
     0x207765, 0x207A75, 0x626572, 0x636820, 0x636865, 0x636874, 0x646173, 0x64656E, 0x646572, 0x646965, 0x652064, 0x652073, 0x65696E, 0x656974, 0x656E20, 0x657220, 
     0x657320, 0x67656E, 0x68656E, 0x687420, 0x696368, 0x696520, 0x696E20, 0x696E65, 0x697420, 0x6C6963, 0x6C6C65, 0x6E2061, 0x6E2064, 0x6E2073, 0x6E6420, 0x6E6465, 
     0x6E6520, 0x6E6720, 0x6E6765, 0x6E7465, 0x722064, 0x726465, 0x726569, 0x736368, 0x737465, 0x742064, 0x746520, 0x74656E, 0x746572, 0x756E64, 0x756E67, 0x766572, 
 };
 
-const int32_t CharsetRecog_8859_1_es::ngrams[] = {
+static const int32_t ngrams_8859_1_es[] = {
     0x206120, 0x206361, 0x20636F, 0x206465, 0x20656C, 0x20656E, 0x206573, 0x20696E, 0x206C61, 0x206C6F, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207265, 0x207365, 
     0x20756E, 0x207920, 0x612063, 0x612064, 0x612065, 0x61206C, 0x612070, 0x616369, 0x61646F, 0x616C20, 0x617220, 0x617320, 0x6369F3, 0x636F6E, 0x646520, 0x64656C, 
     0x646F20, 0x652064, 0x652065, 0x65206C, 0x656C20, 0x656E20, 0x656E74, 0x657320, 0x657374, 0x69656E, 0x69F36E, 0x6C6120, 0x6C6F73, 0x6E2065, 0x6E7465, 0x6F2064, 
     0x6F2065, 0x6F6E20, 0x6F7220, 0x6F7320, 0x706172, 0x717565, 0x726120, 0x726573, 0x732064, 0x732065, 0x732070, 0x736520, 0x746520, 0x746F20, 0x756520, 0xF36E20, 
 };
 
-const int32_t CharsetRecog_8859_1_fr::ngrams[] = {
+static const int32_t ngrams_8859_1_fr[] = {
     0x206175, 0x20636F, 0x206461, 0x206465, 0x206475, 0x20656E, 0x206574, 0x206C61, 0x206C65, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207365, 0x20736F, 0x20756E,
     0x20E020, 0x616E74, 0x617469, 0x636520, 0x636F6E, 0x646520, 0x646573, 0x647520, 0x652061, 0x652063, 0x652064, 0x652065, 0x65206C, 0x652070, 0x652073, 0x656E20,
     0x656E74, 0x657220, 0x657320, 0x657420, 0x657572, 0x696F6E, 0x697320, 0x697420, 0x6C6120, 0x6C6520, 0x6C6573, 0x6D656E, 0x6E2064, 0x6E6520, 0x6E7320, 0x6E7420,
     0x6F6E20, 0x6F6E74, 0x6F7572, 0x717565, 0x72206C, 0x726520, 0x732061, 0x732064, 0x732065, 0x73206C, 0x732070, 0x742064, 0x746520, 0x74696F, 0x756520, 0x757220,
 };
 
-const int32_t CharsetRecog_8859_1_it::ngrams[] = {
+static const int32_t ngrams_8859_1_it[] = {
     0x20616C, 0x206368, 0x20636F, 0x206465, 0x206469, 0x206520, 0x20696C, 0x20696E, 0x206C61, 0x207065, 0x207072, 0x20756E, 0x612063, 0x612064, 0x612070, 0x612073,
     0x61746F, 0x636865, 0x636F6E, 0x64656C, 0x646920, 0x652061, 0x652063, 0x652064, 0x652069, 0x65206C, 0x652070, 0x652073, 0x656C20, 0x656C6C, 0x656E74, 0x657220,
     0x686520, 0x692061, 0x692063, 0x692064, 0x692073, 0x696120, 0x696C20, 0x696E20, 0x696F6E, 0x6C6120, 0x6C6520, 0x6C6920, 0x6C6C61, 0x6E6520, 0x6E6920, 0x6E6F20,
     0x6E7465, 0x6F2061, 0x6F2064, 0x6F2069, 0x6F2073, 0x6F6E20, 0x6F6E65, 0x706572, 0x726120, 0x726520, 0x736920, 0x746120, 0x746520, 0x746920, 0x746F20, 0x7A696F,
 };
 
-const int32_t CharsetRecog_8859_1_nl::ngrams[] = {
+static const int32_t ngrams_8859_1_nl[] = {
     0x20616C, 0x206265, 0x206461, 0x206465, 0x206469, 0x206565, 0x20656E, 0x206765, 0x206865, 0x20696E, 0x206D61, 0x206D65, 0x206F70, 0x207465, 0x207661, 0x207665,
     0x20766F, 0x207765, 0x207A69, 0x61616E, 0x616172, 0x616E20, 0x616E64, 0x617220, 0x617420, 0x636874, 0x646520, 0x64656E, 0x646572, 0x652062, 0x652076, 0x65656E,
     0x656572, 0x656E20, 0x657220, 0x657273, 0x657420, 0x67656E, 0x686574, 0x696520, 0x696E20, 0x696E67, 0x697320, 0x6E2062, 0x6E2064, 0x6E2065, 0x6E2068, 0x6E206F,
     0x6E2076, 0x6E6465, 0x6E6720, 0x6F6E64, 0x6F6F72, 0x6F7020, 0x6F7220, 0x736368, 0x737465, 0x742064, 0x746520, 0x74656E, 0x746572, 0x76616E, 0x766572, 0x766F6F,
 };
 
-const int32_t CharsetRecog_8859_1_no::ngrams[] = {
+static const int32_t ngrams_8859_1_no[] = {
     0x206174, 0x206176, 0x206465, 0x20656E, 0x206572, 0x20666F, 0x206861, 0x206920, 0x206D65, 0x206F67, 0x2070E5, 0x207365, 0x20736B, 0x20736F, 0x207374, 0x207469,
     0x207669, 0x20E520, 0x616E64, 0x617220, 0x617420, 0x646520, 0x64656E, 0x646574, 0x652073, 0x656420, 0x656E20, 0x656E65, 0x657220, 0x657265, 0x657420, 0x657474,
     0x666F72, 0x67656E, 0x696B6B, 0x696C20, 0x696E67, 0x6B6520, 0x6B6B65, 0x6C6520, 0x6C6C65, 0x6D6564, 0x6D656E, 0x6E2073, 0x6E6520, 0x6E6720, 0x6E6765, 0x6E6E65,
     0x6F6720, 0x6F6D20, 0x6F7220, 0x70E520, 0x722073, 0x726520, 0x736F6D, 0x737465, 0x742073, 0x746520, 0x74656E, 0x746572, 0x74696C, 0x747420, 0x747465, 0x766572,
 };
 
-const int32_t CharsetRecog_8859_1_pt::ngrams[] = {
+static const int32_t ngrams_8859_1_pt[] = {
     0x206120, 0x20636F, 0x206461, 0x206465, 0x20646F, 0x206520, 0x206573, 0x206D61, 0x206E6F, 0x206F20, 0x207061, 0x20706F, 0x207072, 0x207175, 0x207265, 0x207365,
     0x20756D, 0x612061, 0x612063, 0x612064, 0x612070, 0x616465, 0x61646F, 0x616C20, 0x617220, 0x617261, 0x617320, 0x636F6D, 0x636F6E, 0x646120, 0x646520, 0x646F20,
     0x646F73, 0x652061, 0x652064, 0x656D20, 0x656E74, 0x657320, 0x657374, 0x696120, 0x696361, 0x6D656E, 0x6E7465, 0x6E746F, 0x6F2061, 0x6F2063, 0x6F2064, 0x6F2065,
     0x6F2070, 0x6F7320, 0x706172, 0x717565, 0x726120, 0x726573, 0x732061, 0x732064, 0x732065, 0x732070, 0x737461, 0x746520, 0x746F20, 0x756520, 0xE36F20, 0xE7E36F,
 };
 
-const int32_t CharsetRecog_8859_1_sv::ngrams[] = {
+static const int32_t ngrams_8859_1_sv[] = {
     0x206174, 0x206176, 0x206465, 0x20656E, 0x2066F6, 0x206861, 0x206920, 0x20696E, 0x206B6F, 0x206D65, 0x206F63, 0x2070E5, 0x20736B, 0x20736F, 0x207374, 0x207469,
     0x207661, 0x207669, 0x20E472, 0x616465, 0x616E20, 0x616E64, 0x617220, 0x617474, 0x636820, 0x646520, 0x64656E, 0x646572, 0x646574, 0x656420, 0x656E20, 0x657220,
     0x657420, 0x66F672, 0x67656E, 0x696C6C, 0x696E67, 0x6B6120, 0x6C6C20, 0x6D6564, 0x6E2073, 0x6E6120, 0x6E6465, 0x6E6720, 0x6E6765, 0x6E696E, 0x6F6368, 0x6F6D20,
     0x6F6E20, 0x70E520, 0x722061, 0x722073, 0x726120, 0x736B61, 0x736F6D, 0x742073, 0x746120, 0x746520, 0x746572, 0x74696C, 0x747420, 0x766172, 0xE47220, 0xF67220,
 };
 
-const int32_t CharsetRecog_8859_2_cs::ngrams[] = {
+static const int32_t ngrams_8859_2_cs[] = {
     0x206120, 0x206279, 0x20646F, 0x206A65, 0x206E61, 0x206E65, 0x206F20, 0x206F64, 0x20706F, 0x207072, 0x2070F8, 0x20726F, 0x207365, 0x20736F, 0x207374, 0x20746F,
     0x207620, 0x207679, 0x207A61, 0x612070, 0x636520, 0x636820, 0x652070, 0x652073, 0x652076, 0x656D20, 0x656EED, 0x686F20, 0x686F64, 0x697374, 0x6A6520, 0x6B7465,
     0x6C6520, 0x6C6920, 0x6E6120, 0x6EE920, 0x6EEC20, 0x6EED20, 0x6F2070, 0x6F646E, 0x6F6A69, 0x6F7374, 0x6F7520, 0x6F7661, 0x706F64, 0x706F6A, 0x70726F, 0x70F865,
     0x736520, 0x736F75, 0x737461, 0x737469, 0x73746E, 0x746572, 0x746EED, 0x746F20, 0x752070, 0xBE6520, 0xE16EED, 0xE9686F, 0xED2070, 0xED2073, 0xED6D20, 0xF86564,
 };
 
-const int32_t CharsetRecog_8859_2_hu::ngrams[] = {
+static const int32_t ngrams_8859_2_hu[] = {
     0x206120, 0x20617A, 0x206265, 0x206567, 0x20656C, 0x206665, 0x206861, 0x20686F, 0x206973, 0x206B65, 0x206B69, 0x206BF6, 0x206C65, 0x206D61, 0x206D65, 0x206D69,
     0x206E65, 0x20737A, 0x207465, 0x20E973, 0x612061, 0x61206B, 0x61206D, 0x612073, 0x616B20, 0x616E20, 0x617A20, 0x62616E, 0x62656E, 0x656779, 0x656B20, 0x656C20,
     0x656C65, 0x656D20, 0x656E20, 0x657265, 0x657420, 0x657465, 0x657474, 0x677920, 0x686F67, 0x696E74, 0x697320, 0x6B2061, 0x6BF67A, 0x6D6567, 0x6D696E, 0x6E2061,
     0x6E616B, 0x6E656B, 0x6E656D, 0x6E7420, 0x6F6779, 0x732061, 0x737A65, 0x737A74, 0x737AE1, 0x73E967, 0x742061, 0x747420, 0x74E173, 0x7A6572, 0xE16E20, 0xE97320,
 };
 
-const int32_t CharsetRecog_8859_2_pl::ngrams[] = {
+static const int32_t ngrams_8859_2_pl[] = {
     0x20637A, 0x20646F, 0x206920, 0x206A65, 0x206B6F, 0x206D61, 0x206D69, 0x206E61, 0x206E69, 0x206F64, 0x20706F, 0x207072, 0x207369, 0x207720, 0x207769, 0x207779,
     0x207A20, 0x207A61, 0x612070, 0x612077, 0x616E69, 0x636820, 0x637A65, 0x637A79, 0x646F20, 0x647A69, 0x652070, 0x652073, 0x652077, 0x65207A, 0x65676F, 0x656A20,
     0x656D20, 0x656E69, 0x676F20, 0x696120, 0x696520, 0x69656A, 0x6B6120, 0x6B6920, 0x6B6965, 0x6D6965, 0x6E6120, 0x6E6961, 0x6E6965, 0x6F2070, 0x6F7761, 0x6F7769,
     0x706F6C, 0x707261, 0x70726F, 0x70727A, 0x727A65, 0x727A79, 0x7369EA, 0x736B69, 0x737461, 0x776965, 0x796368, 0x796D20, 0x7A6520, 0x7A6965, 0x7A7920, 0xF37720,
 };
 
-const int32_t CharsetRecog_8859_2_ro::ngrams[] = {
+static const int32_t ngrams_8859_2_ro[] = {
     0x206120, 0x206163, 0x206361, 0x206365, 0x20636F, 0x206375, 0x206465, 0x206469, 0x206C61, 0x206D61, 0x207065, 0x207072, 0x207365, 0x2073E3, 0x20756E, 0x20BA69,
     0x20EE6E, 0x612063, 0x612064, 0x617265, 0x617420, 0x617465, 0x617520, 0x636172, 0x636F6E, 0x637520, 0x63E320, 0x646520, 0x652061, 0x652063, 0x652064, 0x652070,
     0x652073, 0x656120, 0x656920, 0x656C65, 0x656E74, 0x657374, 0x692061, 0x692063, 0x692064, 0x692070, 0x696520, 0x696920, 0x696E20, 0x6C6120, 0x6C6520, 0x6C6F72,
     0x6C7569, 0x6E6520, 0x6E7472, 0x6F7220, 0x70656E, 0x726520, 0x726561, 0x727520, 0x73E320, 0x746520, 0x747275, 0x74E320, 0x756920, 0x756C20, 0xBA6920, 0xEE6E20,
 };
 
-const int32_t CharsetRecog_8859_5_ru::ngrams[] = {
+static const int32_t ngrams_8859_5_ru[] = {
     0x20D220, 0x20D2DE, 0x20D4DE, 0x20D7D0, 0x20D820, 0x20DAD0, 0x20DADE, 0x20DDD0, 0x20DDD5, 0x20DED1, 0x20DFDE, 0x20DFE0, 0x20E0D0, 0x20E1DE, 0x20E1E2, 0x20E2DE,
     0x20E7E2, 0x20EDE2, 0xD0DDD8, 0xD0E2EC, 0xD3DE20, 0xD5DBEC, 0xD5DDD8, 0xD5E1E2, 0xD5E220, 0xD820DF, 0xD8D520, 0xD8D820, 0xD8EF20, 0xDBD5DD, 0xDBD820, 0xDBECDD,
     0xDDD020, 0xDDD520, 0xDDD8D5, 0xDDD8EF, 0xDDDE20, 0xDDDED2, 0xDE20D2, 0xDE20DF, 0xDE20E1, 0xDED220, 0xDED2D0, 0xDED3DE, 0xDED920, 0xDEDBEC, 0xDEDC20, 0xDEE1E2,
     0xDFDEDB, 0xDFE0D5, 0xDFE0D8, 0xDFE0DE, 0xE0D0D2, 0xE0D5D4, 0xE1E2D0, 0xE1E2D2, 0xE1E2D8, 0xE1EF20, 0xE2D5DB, 0xE2DE20, 0xE2DEE0, 0xE2EC20, 0xE7E2DE, 0xEBE520,
 };
 
-const int32_t CharsetRecog_8859_6_ar::ngrams[] = {
+static const int32_t ngrams_8859_6_ar[] = {
     0x20C7E4, 0x20C7E6, 0x20C8C7, 0x20D9E4, 0x20E1EA, 0x20E4E4, 0x20E5E6, 0x20E8C7, 0xC720C7, 0xC7C120, 0xC7CA20, 0xC7D120, 0xC7E420, 0xC7E4C3, 0xC7E4C7, 0xC7E4C8,
     0xC7E4CA, 0xC7E4CC, 0xC7E4CD, 0xC7E4CF, 0xC7E4D3, 0xC7E4D9, 0xC7E4E2, 0xC7E4E5, 0xC7E4E8, 0xC7E4EA, 0xC7E520, 0xC7E620, 0xC7E6CA, 0xC820C7, 0xC920C7, 0xC920E1,
     0xC920E4, 0xC920E5, 0xC920E8, 0xCA20C7, 0xCF20C7, 0xCFC920, 0xD120C7, 0xD1C920, 0xD320C7, 0xD920C7, 0xD9E4E9, 0xE1EA20, 0xE420C7, 0xE4C920, 0xE4E920, 0xE4EA20,
     0xE520C7, 0xE5C720, 0xE5C920, 0xE5E620, 0xE620C7, 0xE720C7, 0xE7C720, 0xE8C7E4, 0xE8E620, 0xE920C7, 0xEA20C7, 0xEA20E5, 0xEA20E8, 0xEAC920, 0xEAD120, 0xEAE620,
 };
 
-const int32_t CharsetRecog_8859_7_el::ngrams[] = {
+static const int32_t ngrams_8859_7_el[] = {
     0x20E1ED, 0x20E1F0, 0x20E3E9, 0x20E4E9, 0x20E5F0, 0x20E720, 0x20EAE1, 0x20ECE5, 0x20EDE1, 0x20EF20, 0x20F0E1, 0x20F0EF, 0x20F0F1, 0x20F3F4, 0x20F3F5, 0x20F4E7,
     0x20F4EF, 0xDFE120, 0xE120E1, 0xE120F4, 0xE1E920, 0xE1ED20, 0xE1F0FC, 0xE1F220, 0xE3E9E1, 0xE5E920, 0xE5F220, 0xE720F4, 0xE7ED20, 0xE7F220, 0xE920F4, 0xE9E120,
     0xE9EADE, 0xE9F220, 0xEAE1E9, 0xEAE1F4, 0xECE520, 0xED20E1, 0xED20E5, 0xED20F0, 0xEDE120, 0xEFF220, 0xEFF520, 0xF0EFF5, 0xF0F1EF, 0xF0FC20, 0xF220E1, 0xF220E5,
     0xF220EA, 0xF220F0, 0xF220F4, 0xF3E520, 0xF3E720, 0xF3F4EF, 0xF4E120, 0xF4E1E9, 0xF4E7ED, 0xF4E7F2, 0xF4E9EA, 0xF4EF20, 0xF4EFF5, 0xF4F9ED, 0xF9ED20, 0xFEED20,
 };
 
-const int32_t CharsetRecog_8859_8_I_he::ngrams[] = {
+static const int32_t ngrams_8859_8_I_he[] = {
     0x20E0E5, 0x20E0E7, 0x20E0E9, 0x20E0FA, 0x20E1E9, 0x20E1EE, 0x20E4E0, 0x20E4E5, 0x20E4E9, 0x20E4EE, 0x20E4F2, 0x20E4F9, 0x20E4FA, 0x20ECE0, 0x20ECE4, 0x20EEE0,
     0x20F2EC, 0x20F9EC, 0xE0FA20, 0xE420E0, 0xE420E1, 0xE420E4, 0xE420EC, 0xE420EE, 0xE420F9, 0xE4E5E0, 0xE5E020, 0xE5ED20, 0xE5EF20, 0xE5F820, 0xE5FA20, 0xE920E4,
     0xE9E420, 0xE9E5FA, 0xE9E9ED, 0xE9ED20, 0xE9EF20, 0xE9F820, 0xE9FA20, 0xEC20E0, 0xEC20E4, 0xECE020, 0xECE420, 0xED20E0, 0xED20E1, 0xED20E4, 0xED20EC, 0xED20EE,
     0xED20F9, 0xEEE420, 0xEF20E4, 0xF0E420, 0xF0E920, 0xF0E9ED, 0xF2EC20, 0xF820E4, 0xF8E9ED, 0xF9EC20, 0xFA20E0, 0xFA20E1, 0xFA20E4, 0xFA20EC, 0xFA20EE, 0xFA20F9,
 };
 
-const int32_t CharsetRecog_8859_8_he::ngrams[] = {
+static const int32_t ngrams_8859_8_he[] = {
     0x20E0E5, 0x20E0EC, 0x20E4E9, 0x20E4EC, 0x20E4EE, 0x20E4F0, 0x20E9F0, 0x20ECF2, 0x20ECF9, 0x20EDE5, 0x20EDE9, 0x20EFE5, 0x20EFE9, 0x20F8E5, 0x20F8E9, 0x20FAE0,
     0x20FAE5, 0x20FAE9, 0xE020E4, 0xE020EC, 0xE020ED, 0xE020FA, 0xE0E420, 0xE0E5E4, 0xE0EC20, 0xE0EE20, 0xE120E4, 0xE120ED, 0xE120FA, 0xE420E4, 0xE420E9, 0xE420EC,
     0xE420ED, 0xE420EF, 0xE420F8, 0xE420FA, 0xE4EC20, 0xE5E020, 0xE5E420, 0xE7E020, 0xE9E020, 0xE9E120, 0xE9E420, 0xEC20E4, 0xEC20ED, 0xEC20FA, 0xECF220, 0xECF920,
     0xEDE9E9, 0xEDE9F0, 0xEDE9F8, 0xEE20E4, 0xEE20ED, 0xEE20FA, 0xEEE120, 0xEEE420, 0xF2E420, 0xF920E4, 0xF920ED, 0xF920FA, 0xF9E420, 0xFAE020, 0xFAE420, 0xFAE5E9,
 };
 
-const int32_t CharsetRecog_8859_9_tr::ngrams[] = {
+static const int32_t ngrams_8859_9_tr[] = {
     0x206261, 0x206269, 0x206275, 0x206461, 0x206465, 0x206765, 0x206861, 0x20696C, 0x206B61, 0x206B6F, 0x206D61, 0x206F6C, 0x207361, 0x207461, 0x207665, 0x207961,
     0x612062, 0x616B20, 0x616C61, 0x616D61, 0x616E20, 0x616EFD, 0x617220, 0x617261, 0x6172FD, 0x6173FD, 0x617961, 0x626972, 0x646120, 0x646520, 0x646920, 0x652062,
     0x65206B, 0x656469, 0x656E20, 0x657220, 0x657269, 0x657369, 0x696C65, 0x696E20, 0x696E69, 0x697220, 0x6C616E, 0x6C6172, 0x6C6520, 0x6C6572, 0x6E2061, 0x6E2062,
@@ -686,7 +686,7 @@ CharsetRecog_8859_1_en::~CharsetRecog_8859_1_en()
 
 int32_t CharsetRecog_8859_1_en::match(InputText *textIn)
 {
-    int32_t result = match_sbcs(textIn, ngrams, charMap);
+    int32_t result = match_sbcs(textIn, ngrams_8859_1_en, charMap_8859_1);
 
    // printf("8859_1_en: result = %d\n", result);
 	return result; //match_sbcs(textIn, ngrams, charMap);
@@ -704,7 +704,7 @@ const char *CharsetRecog_8859_1_da::getLanguage() const
     
 int32_t CharsetRecog_8859_1_da::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_da, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_de::~CharsetRecog_8859_1_de() {}
@@ -716,7 +716,7 @@ const char *CharsetRecog_8859_1_de::getLanguage() const
     
 int32_t CharsetRecog_8859_1_de::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_de, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_es::~CharsetRecog_8859_1_es()
@@ -731,7 +731,7 @@ const char *CharsetRecog_8859_1_es::getLanguage() const
     
 int32_t CharsetRecog_8859_1_es::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_es, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_fr::~CharsetRecog_8859_1_fr()
@@ -746,7 +746,7 @@ const char *CharsetRecog_8859_1_fr::getLanguage() const
     
 int32_t CharsetRecog_8859_1_fr::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_fr, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_it::~CharsetRecog_8859_1_it()
@@ -761,7 +761,7 @@ const char *CharsetRecog_8859_1_it::getLanguage() const
     
 int32_t CharsetRecog_8859_1_it::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_it, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_nl::~CharsetRecog_8859_1_nl()
@@ -776,7 +776,7 @@ const char *CharsetRecog_8859_1_nl::getLanguage() const
     
 int32_t CharsetRecog_8859_1_nl::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_nl, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_no::~CharsetRecog_8859_1_no() {}
@@ -788,7 +788,7 @@ const char *CharsetRecog_8859_1_no::getLanguage() const
     
 int32_t CharsetRecog_8859_1_no::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_no, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_pt::~CharsetRecog_8859_1_pt()
@@ -803,7 +803,7 @@ const char *CharsetRecog_8859_1_pt::getLanguage() const
     
 int32_t CharsetRecog_8859_1_pt::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_pt, charMap_8859_1);
 }
 
 CharsetRecog_8859_1_sv::~CharsetRecog_8859_1_sv() {}
@@ -815,7 +815,7 @@ const char *CharsetRecog_8859_1_sv::getLanguage() const
     
 int32_t CharsetRecog_8859_1_sv::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_1_sv, charMap_8859_1);
 }
 
 CharsetRecog_8859_2::~CharsetRecog_8859_2()
@@ -840,7 +840,7 @@ const char *CharsetRecog_8859_2_cs::getLanguage() const
     
 int32_t CharsetRecog_8859_2_cs::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_2_cs, charMap_8859_2);
 }
 
 CharsetRecog_8859_2_hu::~CharsetRecog_8859_2_hu()
@@ -855,7 +855,7 @@ const char *CharsetRecog_8859_2_hu::getLanguage() const
     
 int32_t CharsetRecog_8859_2_hu::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_2_hu, charMap_8859_2);
 }
 
 CharsetRecog_8859_2_pl::~CharsetRecog_8859_2_pl()
@@ -870,7 +870,7 @@ const char *CharsetRecog_8859_2_pl::getLanguage() const
     
 int32_t CharsetRecog_8859_2_pl::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_2_pl, charMap_8859_2);
 }
 
 CharsetRecog_8859_2_ro::~CharsetRecog_8859_2_ro()
@@ -885,7 +885,7 @@ const char *CharsetRecog_8859_2_ro::getLanguage() const
     
 int32_t CharsetRecog_8859_2_ro::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_2_ro, charMap_8859_2);
 }
 
 CharsetRecog_8859_5::~CharsetRecog_8859_5()
@@ -910,7 +910,7 @@ const char *CharsetRecog_8859_5_ru::getLanguage() const
     
 int32_t CharsetRecog_8859_5_ru::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_5_ru, charMap_8859_5);
 }
 
 CharsetRecog_8859_6::~CharsetRecog_8859_6()
@@ -935,7 +935,7 @@ const char *CharsetRecog_8859_6_ar::getLanguage() const
     
 int32_t CharsetRecog_8859_6_ar::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_6_ar, charMap_8859_6);
 }
 
 CharsetRecog_8859_7::~CharsetRecog_8859_7()
@@ -960,7 +960,7 @@ const char *CharsetRecog_8859_7_el::getLanguage() const
     
 int32_t CharsetRecog_8859_7_el::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_7_el, charMap_8859_7);
 }
 
 CharsetRecog_8859_8::~CharsetRecog_8859_8()
@@ -985,7 +985,7 @@ const char *CharsetRecog_8859_8_I_he::getLanguage() const
     
 int32_t CharsetRecog_8859_8_I_he::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_8_I_he, charMap_8859_8);
 }
 
 CharsetRecog_8859_8_he::~CharsetRecog_8859_8_he()
@@ -1000,7 +1000,7 @@ const char *CharsetRecog_8859_8_he::getLanguage() const
     
 int32_t CharsetRecog_8859_8_he::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_8_he, charMap_8859_8);
 }
 
 CharsetRecog_8859_9::~CharsetRecog_8859_9()
@@ -1025,7 +1025,7 @@ const char *CharsetRecog_8859_9_tr::getLanguage() const
     
 int32_t CharsetRecog_8859_9_tr::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_8859_9_tr, charMap_8859_9);
 }
 
 CharsetRecog_windows_1256::~CharsetRecog_windows_1256()
@@ -1045,7 +1045,7 @@ const char *CharsetRecog_windows_1256::getLanguage() const
     
 int32_t CharsetRecog_windows_1256::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_windows_1256, charMap_windows_1256);
 }
 
 CharsetRecog_windows_1251::~CharsetRecog_windows_1251()
@@ -1065,7 +1065,7 @@ const char *CharsetRecog_windows_1251::getLanguage() const
     
 int32_t CharsetRecog_windows_1251::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_windows_1251, charMap_windows_1251);
 }
 
 CharsetRecog_KOI8_R::~CharsetRecog_KOI8_R()
@@ -1085,7 +1085,7 @@ const char *CharsetRecog_KOI8_R::getLanguage() const
     
 int32_t CharsetRecog_KOI8_R::match(InputText *textIn)
 {
-	return match_sbcs(textIn, ngrams, charMap);
+	return match_sbcs(textIn, ngrams_KOI8_R, charMap_KOI8_R);
 }
 
 U_NAMESPACE_END
diff --git a/icu4c/source/i18n/csrsbcs.h b/icu4c/source/i18n/csrsbcs.h
index 16edb88e495..aa63248673f 100644
--- a/icu4c/source/i18n/csrsbcs.h
+++ b/icu4c/source/i18n/csrsbcs.h
@@ -64,9 +64,6 @@ class CharsetRecog_sbcs : public CharsetRecognizer
 
 class CharsetRecog_8859_1 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_1();
 	
@@ -75,8 +72,6 @@ class CharsetRecog_8859_1 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_2 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
  public:
     virtual ~CharsetRecog_8859_2();
 	
@@ -85,9 +80,6 @@ class CharsetRecog_8859_2 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_5 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_5();
 	
@@ -96,9 +88,6 @@ class CharsetRecog_8859_5 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_6 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_6();
 	
@@ -107,9 +96,6 @@ class CharsetRecog_8859_6 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_7 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_7();
 	
@@ -118,9 +104,6 @@ class CharsetRecog_8859_7 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_8 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_8();
 	
@@ -129,9 +112,6 @@ class CharsetRecog_8859_8 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_9 : public CharsetRecog_sbcs
 {
- protected:
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_8859_9();
 	
@@ -140,9 +120,6 @@ class CharsetRecog_8859_9 : public CharsetRecog_sbcs
 
 class CharsetRecog_8859_1_en : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_en();
 	
@@ -153,9 +130,6 @@ class CharsetRecog_8859_1_en : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_da : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_da();
 	
@@ -166,9 +140,6 @@ class CharsetRecog_8859_1_da : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_de : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_de();
 	
@@ -179,9 +150,6 @@ class CharsetRecog_8859_1_de : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_es : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_es();
 	
@@ -192,9 +160,6 @@ class CharsetRecog_8859_1_es : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_fr : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_fr();
 	
@@ -205,9 +170,6 @@ class CharsetRecog_8859_1_fr : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_it : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_it();
 	
@@ -218,9 +180,6 @@ class CharsetRecog_8859_1_it : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_nl : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_nl();
 	
@@ -231,9 +190,6 @@ class CharsetRecog_8859_1_nl : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_no : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_no();
 	
@@ -244,9 +200,6 @@ class CharsetRecog_8859_1_no : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_pt : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_pt();
 	
@@ -257,9 +210,6 @@ class CharsetRecog_8859_1_pt : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_1_sv : public CharsetRecog_8859_1
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_1_sv();
 	
@@ -270,9 +220,6 @@ class CharsetRecog_8859_1_sv : public CharsetRecog_8859_1
 
 class CharsetRecog_8859_2_cs : public CharsetRecog_8859_2
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_2_cs();
 	
@@ -283,9 +230,6 @@ class CharsetRecog_8859_2_cs : public CharsetRecog_8859_2
 
 class CharsetRecog_8859_2_hu : public CharsetRecog_8859_2
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_2_hu();
 	
@@ -296,9 +240,6 @@ class CharsetRecog_8859_2_hu : public CharsetRecog_8859_2
 
 class CharsetRecog_8859_2_pl : public CharsetRecog_8859_2
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_2_pl();
 	
@@ -309,9 +250,6 @@ class CharsetRecog_8859_2_pl : public CharsetRecog_8859_2
 
 class CharsetRecog_8859_2_ro : public CharsetRecog_8859_2
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_2_ro();
 	
@@ -322,9 +260,6 @@ class CharsetRecog_8859_2_ro : public CharsetRecog_8859_2
 
 class CharsetRecog_8859_5_ru : public CharsetRecog_8859_5
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_5_ru();
 	
@@ -335,9 +270,6 @@ class CharsetRecog_8859_5_ru : public CharsetRecog_8859_5
 
 class CharsetRecog_8859_6_ar : public CharsetRecog_8859_6
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_6_ar();
 	
@@ -348,9 +280,6 @@ class CharsetRecog_8859_6_ar : public CharsetRecog_8859_6
 
 class CharsetRecog_8859_7_el : public CharsetRecog_8859_7
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_7_el();
 	
@@ -361,9 +290,6 @@ class CharsetRecog_8859_7_el : public CharsetRecog_8859_7
 
 class CharsetRecog_8859_8_I_he : public CharsetRecog_8859_8
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_8_I_he();
 	
@@ -374,9 +300,6 @@ class CharsetRecog_8859_8_I_he : public CharsetRecog_8859_8
 
 class CharsetRecog_8859_8_he : public CharsetRecog_8859_8
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_8_he ();
 	
@@ -387,9 +310,6 @@ class CharsetRecog_8859_8_he : public CharsetRecog_8859_8
 
 class CharsetRecog_8859_9_tr : public CharsetRecog_8859_9
 {
- private:
-    static const int32_t ngrams[];
-
  public:
     virtual ~CharsetRecog_8859_9_tr ();
 	
@@ -400,10 +320,6 @@ class CharsetRecog_8859_9_tr : public CharsetRecog_8859_9
 
 class CharsetRecog_windows_1256 : public CharsetRecog_sbcs
 {
- private:
-    static const int32_t ngrams[];
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_windows_1256();
 	
@@ -416,10 +332,6 @@ class CharsetRecog_windows_1256 : public CharsetRecog_sbcs
 
 class CharsetRecog_windows_1251 : public CharsetRecog_sbcs
 {
- private:
-    static const int32_t ngrams[];
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_windows_1251();
 	
@@ -433,10 +345,6 @@ class CharsetRecog_windows_1251 : public CharsetRecog_sbcs
         
 class CharsetRecog_KOI8_R : public CharsetRecog_sbcs
 {
- private:
-    static const int32_t ngrams[];
-    static const uint8_t charMap[];
-
  public:
     virtual ~CharsetRecog_KOI8_R();