third_party/hunspell/src/hunspell/csutil.cxx - Issue 2544793003: [spellcheck] Updated Hunspell to 1.5.4

Unified Diff: third_party/hunspell/src/hunspell/csutil.cxx

Issue 2544793003: [spellcheck] Updated Hunspell to 1.5.4 (Closed)

Patch Set: Updated patch with encoding change Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: third_party/hunspell/src/hunspell/csutil.cxx

diff --git a/third_party/hunspell/src/hunspell/csutil.cxx b/third_party/hunspell/src/hunspell/csutil.cxx

index 0f2267fb74bb5edaa88382c5fe7a3d67d25cee63..ac5cd986f2fe4fbb23cce6c2dcf78b18079a6f24 100644

--- a/third_party/hunspell/src/hunspell/csutil.cxx

+++ b/third_party/hunspell/src/hunspell/csutil.cxx

@@ -1,10 +1,82 @@

-#include "license.hunspell"

-#include "license.myspell"

-#include <stdlib.h>

+/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Hunspell, based on MySpell.

+ *

+ * The Initial Developers of the Original Code are

+ * Kevin Hendricks (MySpell) and Németh László (Hunspell).

+ *

+ * Contributor(s): David Einstein, Davide Prina, Giuseppe Modugno,

+ * Gianluca Turconi, Simon Brouwer, Noll János, Bíró Árpád,

+ * Goldman Eleonóra, Sarlós Tamás, Bencsáth Boldizsár, Halácsy Péter,

+ * Dvornik László, Gefferth András, Nagy Viktor, Varga Dániel, Chris Halls,

+ * Rene Engelhard, Bram Moolenaar, Dafydd Jones, Harri Pitkänen

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+/*

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright

+ * notice, this list of conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright

+ * notice, this list of conditions and the following disclaimer in the

+ * documentation and/or other materials provided with the distribution.

+ *

+ * 3. All modifications to the source code must be clearly marked as

+ * such. Binary redistributions based on modified source code

+ * must be clearly marked as modified versions in the documentation

+ * and/or other materials provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY KEVIN B. HENDRICKS AND CONTRIBUTORS

+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL

+ * KEVIN B. HENDRICKS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

+ * SUCH DAMAGE.

+ */

+#include <algorithm>

+#include <stdlib.h>

#include <string.h>

-#include <stdio.h>

+#include <stdio.h>

#include <ctype.h>

+#include <sstream>

#include "csutil.hxx"

#include "atypes.hxx"

@@ -17,24 +89,28 @@ struct unicode_info {

unsigned short clower;

};

+#ifdef _WIN32

+#include <windows.h>

+#include <wchar.h>

+#endif

#ifdef OPENOFFICEORG

-# include <unicode/uchar.h>

+#include <unicode/uchar.h>

#else

-# ifndef MOZILLA_CLIENT

-# include "utf_info.cxx"

-# define UTF_LST_LEN (sizeof(utf_lst) / (sizeof(unicode_info)))

-# endif

+#ifndef MOZILLA_CLIENT

+#include "utf_info.cxx"

+#define UTF_LST_LEN (sizeof(utf_lst) / (sizeof(unicode_info)))

+#endif

#endif

#ifdef MOZILLA_CLIENT

#include "nsCOMPtr.h"

-#include "nsServiceManagerUtils.h"

#include "nsIUnicodeEncoder.h"

#include "nsIUnicodeDecoder.h"

#include "nsUnicharUtils.h"

-#include "nsICharsetConverterManager.h"

+#include "mozilla/dom/EncodingUtils.h"

-static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);

+using mozilla::dom::EncodingUtils;

#endif

struct unicode_info2 {

@@ -43,5412 +119,2160 @@ struct unicode_info2 {

unsigned short clower;

};

-static struct unicode_info2 * utf_tbl = NULL;

-static int utf_tbl_count = 0; // utf_tbl can be used by multiple Hunspell instances

+static struct unicode_info2* utf_tbl = NULL;

+static int utf_tbl_count =

+ 0; // utf_tbl can be used by multiple Hunspell instances

-/* only UTF-16 (BMP) implementation */

-char * u16_u8(char * dest, int size, const w_char * src, int srclen) {

- signed char * u8 = (signed char *)dest;

- signed char * u8_max = (signed char *)(u8 + size);

- const w_char * u2 = src;

- const w_char * u2_max = src + srclen;

- while ((u2 < u2_max) && (u8 < u8_max)) {

- if (u2->h) { // > 0xFF

- // XXX 4-byte haven't implemented yet.

- if (u2->h >= 0x08) { // >= 0x800 (3-byte UTF-8 character)

- *u8 = 0xe0 + (u2->h >> 4);

- u8++;

- if (u8 < u8_max) {

- *u8 = 0x80 + ((u2->h & 0xf) << 2) + (u2->l >> 6);

- u8++;

- if (u8 < u8_max) {

- *u8 = 0x80 + (u2->l & 0x3f);

- u8++;

- }

- } else { // < 0x800 (2-byte UTF-8 character)

- *u8 = 0xc0 + (u2->h << 2) + (u2->l >> 6);

- u8++;

- if (u8 < u8_max) {

- *u8 = 0x80 + (u2->l & 0x3f);

- u8++;

- }

- } else { // <= 0xFF

- if (u2->l & 0x80) { // >0x80 (2-byte UTF-8 character)

- *u8 = 0xc0 + (u2->l >> 6);

- u8++;

- if (u8 < u8_max) {

- *u8 = 0x80 + (u2->l & 0x3f);

- u8++;

- }

- } else { // < 0x80 (1-byte UTF-8 character)

- *u8 = u2->l;

- u8++;

- }

- u2++;

+void myopen(std::ifstream& stream, const char* path, std::ios_base::openmode mode)

+#if defined(_WIN32) && defined(_MSC_VER)

+#define WIN32_LONG_PATH_PREFIX "\\\\?\\"

+ if (strncmp(path, WIN32_LONG_PATH_PREFIX, 4) == 0) {

+ int len = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);

+ wchar_t* buff = new wchar_t[len];

+ wchar_t* buff2 = new wchar_t[len];

+ MultiByteToWideChar(CP_UTF8, 0, path, -1, buff, len);

+ if (_wfullpath(buff2, buff, len) != NULL) {

+ stream.open(buff2, mode);

}

- *u8 = '\0';

- return dest;

+ delete [] buff;

+ delete [] buff2;

+ }

+ else

+#endif

+ stream.open(path, mode);

}

+std::string& u16_u8(std::string& dest, const std::vector<w_char>& src) {

+ dest.clear();

+ std::vector<w_char>::const_iterator u2 = src.begin();

+ std::vector<w_char>::const_iterator u2_max = src.end();

+ while (u2 < u2_max) {

+ signed char u8;

+ if (u2->h) { // > 0xFF

+ // XXX 4-byte haven't implemented yet.

+ if (u2->h >= 0x08) { // >= 0x800 (3-byte UTF-8 character)

+ u8 = 0xe0 + (u2->h >> 4);

+ dest.push_back(u8);

+ u8 = 0x80 + ((u2->h & 0xf) << 2) + (u2->l >> 6);

+ dest.push_back(u8);

+ u8 = 0x80 + (u2->l & 0x3f);

+ dest.push_back(u8);

+ } else { // < 0x800 (2-byte UTF-8 character)

+ u8 = 0xc0 + (u2->h << 2) + (u2->l >> 6);

+ dest.push_back(u8);

+ u8 = 0x80 + (u2->l & 0x3f);

+ dest.push_back(u8);

+ }

+ } else { // <= 0xFF

+ if (u2->l & 0x80) { // >0x80 (2-byte UTF-8 character)

+ u8 = 0xc0 + (u2->l >> 6);

+ dest.push_back(u8);

+ u8 = 0x80 + (u2->l & 0x3f);

+ dest.push_back(u8);

+ } else { // < 0x80 (1-byte UTF-8 character)

+ u8 = u2->l;

+ dest.push_back(u8);

+ }

+ ++u2;

+ }

+ return dest;

-/* only UTF-16 (BMP) implementation */

-int u8_u16(w_char * dest, int size, const char * src) {

- const unsigned char * u8 = (const unsigned char*)src;

- w_char * u2 = dest;

- w_char * u2_max = u2 + size;

+int u8_u16(std::vector<w_char>& dest, const std::string& src) {

+ dest.clear();

+ std::string::const_iterator u8 = src.begin();

+ std::string::const_iterator u8_max = src.end();

- while ((u2 < u2_max) && *u8) {

+ while (u8 < u8_max) {

+ w_char u2;

switch ((*u8) & 0xf0) {

- case 0x00:

- case 0x10:

- case 0x20:

- case 0x30:

- case 0x40:

- case 0x50:

- case 0x60:

- case 0x70: {

- u2->h = 0;

- u2->l = *u8;

- break;

- }

- case 0x80:

- case 0x90:

- case 0xa0:

- case 0xb0: {

- HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Unexpected continuation bytes in %ld. character position\n%s\n", static_cast<long>(u8 - (const unsigned char*)src), src);

- u2->h = 0xff;

- u2->l = 0xfd;

- break;

- }

- case 0xc0:

- case 0xd0: { // 2-byte UTF-8 codes

- if ((*(u8+1) & 0xc0) == 0x80) {

- u2->h = (*u8 & 0x1f) >> 2;

- u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);

- u8++;

- } else {

- HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (const unsigned char*)src), src);

- u2->h = 0xff;

- u2->l = 0xfd;

- }

- break;

- }

- case 0xe0: { // 3-byte UTF-8 codes

- if ((*(u8+1) & 0xc0) == 0x80) {

- u2->h = ((*u8 & 0x0f) << 4) + ((*(u8+1) & 0x3f) >> 2);

- u8++;

- if ((*(u8+1) & 0xc0) == 0x80) {

- u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);

- u8++;

- } else {

- HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (const unsigned char*)src), src);

- u2->h = 0xff;

- u2->l = 0xfd;

- }

- } else {

- HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (const unsigned char*)src), src);

- u2->h = 0xff;

- u2->l = 0xfd;

- }

- break;

+ case 0x00:

+ case 0x10:

+ case 0x20:

+ case 0x30:

+ case 0x40:

+ case 0x50:

+ case 0x60:

+ case 0x70: {

+ u2.h = 0;

+ u2.l = *u8;

+ break;

+ }

+ case 0x80:

+ case 0x90:

+ case 0xa0:

+ case 0xb0: {

+ HUNSPELL_WARNING(stderr,

+ "UTF-8 encoding error. Unexpected continuation bytes "

+ "in %ld. character position\n%s\n",

+ static_cast<long>(std::distance(src.begin(), u8)),

+ src.c_str());

+ u2.h = 0xff;

+ u2.l = 0xfd;

+ break;

+ }

+ case 0xc0:

+ case 0xd0: { // 2-byte UTF-8 codes

+ if ((*(u8 + 1) & 0xc0) == 0x80) {

+ u2.h = (*u8 & 0x1f) >> 2;

+ u2.l = (static_cast<unsigned char>(*u8) << 6) + (*(u8 + 1) & 0x3f);

+ ++u8;

+ } else {

+ HUNSPELL_WARNING(stderr,

+ "UTF-8 encoding error. Missing continuation byte in "

+ "%ld. character position:\n%s\n",

+ static_cast<long>(std::distance(src.begin(), u8)),

+ src.c_str());

+ u2.h = 0xff;

+ u2.l = 0xfd;

}

- case 0xf0: { // 4 or more byte UTF-8 codes

- HUNSPELL_WARNING(stderr, "This UTF-8 encoding can't convert to UTF-16:\n%s\n", src);

- u2->h = 0xff;

- u2->l = 0xfd;

- return -1;

+ break;

+ }

+ case 0xe0: { // 3-byte UTF-8 codes

+ if ((*(u8 + 1) & 0xc0) == 0x80) {

+ u2.h = ((*u8 & 0x0f) << 4) + ((*(u8 + 1) & 0x3f) >> 2);

+ ++u8;

+ if ((*(u8 + 1) & 0xc0) == 0x80) {

+ u2.l = (static_cast<unsigned char>(*u8) << 6) + (*(u8 + 1) & 0x3f);

+ ++u8;

+ } else {

+ HUNSPELL_WARNING(stderr,

+ "UTF-8 encoding error. Missing continuation byte "

+ "in %ld. character position:\n%s\n",

+ static_cast<long>(std::distance(src.begin(), u8)),

+ src.c_str());

+ u2.h = 0xff;

+ u2.l = 0xfd;

+ }

+ } else {

+ HUNSPELL_WARNING(stderr,

+ "UTF-8 encoding error. Missing continuation byte in "

+ "%ld. character position:\n%s\n",

+ static_cast<long>(std::distance(src.begin(), u8)),

+ src.c_str());

+ u2.h = 0xff;

+ u2.l = 0xfd;

}

+ break;

+ }

+ case 0xf0: { // 4 or more byte UTF-8 codes

+ HUNSPELL_WARNING(stderr,

+ "This UTF-8 encoding can't convert to UTF-16:\n%s\n",

+ src.c_str());

+ u2.h = 0xff;

+ u2.l = 0xfd;

+ dest.push_back(u2);

+ return -1;

+ }

}

- u8++;

- u2++;

- }

- return (int)(u2 - dest);

+ dest.push_back(u2);

+ ++u8;

+ }

+ return dest.size();

}

-void flag_qsort(unsigned short flags[], int begin, int end) {

- unsigned short reg;

- if (end > begin) {

- unsigned short pivot = flags[begin];

- int l = begin + 1;

- int r = end;

- while(l < r) {

- if (flags[l] <= pivot) {

- l++;

- } else {

- r--;

- reg = flags[l];

- flags[l] = flags[r];

- flags[r] = reg;

- }

- l--;

- reg = flags[begin];

- flags[begin] = flags[l];

- flags[l] = reg;

+namespace {

+class is_any_of {

+ public:

+ explicit is_any_of(const std::string& in) : chars(in) {}

- flag_qsort(flags, begin, l);

- flag_qsort(flags, r, end);

- }

+ bool operator()(char c) { return chars.find(c) != std::string::npos; }

-int flag_bsearch(unsigned short flags[], unsigned short flag, int length) {

- int mid;

- int left = 0;

- int right = length - 1;

- while (left <= right) {

- mid = (left + right) / 2;

- if (flags[mid] == flag) return 1;

- if (flag < flags[mid]) right = mid - 1;

- else left = mid + 1;

- }

- return 0;

+ private:

+ std::string chars;

+};

}

- // strip strings into token based on single char delimiter

- // acts like strsep() but only uses a delim char and not

- // a delim string

- // default delimiter: white space characters

- char * mystrsep(char ** stringp, const char delim)

- {

- char * mp = *stringp;

- if (*mp != '\0') {

- char * dp;

- if (delim) {

- dp = strchr(mp, delim);

- } else {

- // don't use isspace() here, the string can be in some random charset

- // that's way different than the locale's

- for (dp = mp; (*dp && *dp != ' ' && *dp != '\t'); dp++);

- if (!*dp) dp = NULL;

- }

- if (dp) {

- *stringp = dp+1;

- *dp = '\0';

- } else {

- *stringp = mp + strlen(mp);

- }

- return mp;

- }

- return NULL;

- }

+std::string::const_iterator mystrsep(const std::string &str,

+ std::string::const_iterator& start) {

+ std::string::const_iterator end = str.end();

- // replaces strdup with ansi version

- char * mystrdup(const char * s)

- {

- char * d = NULL;

- if (s) {

- size_t sl = strlen(s)+1;

- d = (char *) malloc(sl);

- if (d) {

- memcpy(d,s,sl);

- } else {

- HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");

- }

- return d;

- }

+ is_any_of op(" \t");

+ // don't use isspace() here, the string can be in some random charset

+ // that's way different than the locale's

+ std::string::const_iterator sp = start;

+ while (sp != end && op(*sp))

+ ++sp;

- // strcat for limited length destination string

- char * mystrcat(char * dest, const char * st, int max) {

- int len;

- int len2;

- if (dest == NULL || st == NULL) return dest;

- len = strlen(dest);

- len2 = strlen(st);

- if (len + len2 + 1 > max) return dest;

- strcpy(dest + len, st);

- return dest;

- }

+ std::string::const_iterator dp = sp;

+ while (dp != end && !op(*dp))

+ ++dp;

- // remove cross-platform text line end characters

- void mychomp(char * s)

- {

- size_t k = strlen(s);

- if ((k > 0) && ((*(s+k-1)=='\r') || (*(s+k-1)=='\n'))) *(s+k-1) = '\0';

- if ((k > 1) && (*(s+k-2) == '\r')) *(s+k-2) = '\0';

- }

- // does an ansi strdup of the reverse of a string

- char * myrevstrdup(const char * s)

- {

- char * d = NULL;

- if (s) {

- size_t sl = strlen(s);

- d = (char *) malloc(sl+1);

- if (d) {

- const char * p = s + sl - 1;

- char * q = d;

- while (p >= s) *q++ = *p--;

- *q = '\0';

- } else {

- HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");

- }

- return d;

- }

+ start = dp;

+ return sp;

-// break text to lines

-// return number of lines

-int line_tok(const char * text, char *** lines, char breakchar) {

- int linenum = 0;

- if (!text) {

- return linenum;

- }

- char * dup = mystrdup(text);

- char * p = strchr(dup, breakchar);

- while (p) {

- linenum++;

- *p = '\0';

- p++;

- p = strchr(p, breakchar);

- }

- linenum++;

- *lines = (char **) malloc(linenum * sizeof(char *));

- if (!(*lines)) {

- free(dup);

- return 0;

+// replaces strdup with ansi version

+char* mystrdup(const char* s) {

+ char* d = NULL;

+ if (s) {

+ size_t sl = strlen(s) + 1;

+ d = (char*)malloc(sl);

+ if (d) {

+ memcpy(d, s, sl);

+ } else {

+ HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");

}

+ }

+ return d;

- p = dup;

- int l = 0;

- for (int i = 0; i < linenum; i++) {

- if (*p != '\0') {

- (*lines)[l] = mystrdup(p);

- if (!(*lines)[l]) {

- for (i = 0; i < l; i++) free((*lines)[i]);

- free(dup);

- return 0;

- }

- l++;

- }

- p += strlen(p) + 1;

+// remove cross-platform text line end characters

+void mychomp(std::string& s) {

+ size_t k = s.size();

+ size_t newsize = k;

+ if ((k > 0) && ((s[k - 1] == '\r') || (s[k - 1] == '\n')))

+ --newsize;

+ if ((k > 1) && (s[k - 2] == '\r'))

+ --newsize;

+ s.resize(newsize);

+// break text to lines

+std::vector<std::string> line_tok(const std::string& text, char breakchar) {

+ std::vector<std::string> ret;

+ if (text.empty()) {

+ return ret;

+ }

+ std::stringstream ss(text);

+ std::string tok;

+ while(std::getline(ss, tok, breakchar)) {

+ if (!tok.empty()) {

+ ret.push_back(tok);

}

- free(dup);

- if (!l) free(*lines);

- return l;

+ }

+ return ret;

}

// uniq line in place

-char * line_uniq(char * text, char breakchar) {

- char ** lines;

- int linenum = line_tok(text, &lines, breakchar);

- int i;

- strcpy(text, lines[0]);

- for ( i = 1; i < linenum; i++ ) {

- int dup = 0;

- for (int j = 0; j < i; j++) {

- if (strcmp(lines[i], lines[j]) == 0) dup = 1;

- }

- if (!dup) {

- if ((i > 1) || (*(lines[0]) != '\0')) {

- sprintf(text + strlen(text), "%c", breakchar);

- }

- strcat(text, lines[i]);

- }

+void line_uniq(std::string& text, char breakchar)

+ std::vector<std::string> lines = line_tok(text, breakchar);

+ text.clear();

+ if (lines.empty()) {

+ return;

+ }

+ text = lines[0];

+ for (size_t i = 1; i < lines.size(); ++i) {

+ bool dup = false;

+ for (size_t j = 0; j < i; ++j) {

+ if (lines[i] == lines[j]) {

+ dup = true;

+ break;

+ }

}

- for ( i = 0; i < linenum; i++ ) {

- if (lines[i]) free(lines[i]);

+ if (!dup) {

+ if (!text.empty())

+ text.push_back(breakchar);

+ text.append(lines[i]);

}

- if (lines) free(lines);

- return text;

+ }

}

// uniq and boundary for compound analysis: "1\n\2\n\1" -> " ( \1 | \2 ) "

-char * line_uniq_app(char ** text, char breakchar) {

- if (!strchr(*text, breakchar)) {

- return *text;

- }

- char ** lines;

- int i;

- int linenum = line_tok(*text, &lines, breakchar);

- int dup = 0;

- for (i = 0; i < linenum; i++) {

- for (int j = 0; j < (i - 1); j++) {

- if (strcmp(lines[i], lines[j]) == 0) {

- *(lines[i]) = '\0';

- dup++;

- break;

- }

- if ((linenum - dup) == 1) {

- strcpy(*text, lines[0]);

- freelist(&lines, linenum);

- return *text;

+void line_uniq_app(std::string& text, char breakchar) {

+ if (text.find(breakchar) == std::string::npos) {

+ return;

+ }

+ std::vector<std::string> lines = line_tok(text, breakchar);

+ text.clear();

+ if (lines.empty()) {

+ return;

+ }

+ text = lines[0];

+ for (size_t i = 1; i < lines.size(); ++i) {

+ bool dup = false;

+ for (size_t j = 0; j < i; ++j) {

+ if (lines[i] == lines[j]) {

+ dup = true;

+ break;

+ }

}

- char * newtext = (char *) malloc(strlen(*text) + 2 * linenum + 3 + 1);

- if (newtext) {

- free(*text);

- *text = newtext;

- } else {

- freelist(&lines, linenum);

- return *text;

- }

- strcpy(*text," ( ");

- for (i = 0; i < linenum; i++) if (*(lines[i])) {

- sprintf(*text + strlen(*text), "%s%s", lines[i], " | ");

+ if (!dup) {

+ if (!text.empty())

+ text.push_back(breakchar);

+ text.append(lines[i]);

}

- (*text)[strlen(*text) - 2] = ')'; // " ) "

- freelist(&lines, linenum);

- return *text;

+ }

+ if (lines.size() == 1) {

+ text = lines[0];

+ return;

+ }

+ text.assign(" ( ");

+ for (size_t i = 0; i < lines.size(); ++i) {

+ text.append(lines[i]);

+ text.append(" | ");

+ }

+ text[text.size() - 2] = ')'; // " ) "

}

- // append s to ends of every lines in text

- void strlinecat(char * dest, const char * s)

- {

- char * dup = mystrdup(dest);

- char * source = dup;

- int len = strlen(s);

- if (dup) {

- while (*source) {

- if (*source == '\n') {

- strncpy(dest, s, len);

- dest += len;

- }

- *dest = *source;

- source++; dest++;

- }

- strcpy(dest, s);

- free(dup);

- }

+// append s to ends of every lines in text

+std::string& strlinecat(std::string& str, const std::string& apd) {

+ size_t pos = 0;

+ while ((pos = str.find('\n', pos)) != std::string::npos) {

+ str.insert(pos, apd);

+ pos += apd.length() + 1;

+ }

+ str.append(apd);

+ return str;

-// change \n to char c

-char * tr(char * text, char oldc, char newc) {

- char * p;

- for (p = text; *p; p++) if (*p == oldc) *p = newc;

- return text;

+int fieldlen(const char* r) {

+ int n = 0;

+ while (r && *r != ' ' && *r != '\t' && *r != '\0' && *r != '\n') {

+ r++;

+ n++;

+ }

+ return n;

}

-// morphcmp(): compare MORPH_DERI_SFX, MORPH_INFL_SFX and MORPH_TERM_SFX fields

-// in the first line of the inputs

-// return 0, if inputs equal

-// return 1, if inputs may equal with a secondary suffix

-// otherwise return -1

-int morphcmp(const char * s, const char * t)

- int se = 0;

- int te = 0;

- const char * sl;

- const char * tl;

- const char * olds;

- const char * oldt;

- if (!s || !t) return 1;

- olds = s;

- sl = strchr(s, '\n');

- s = strstr(s, MORPH_DERI_SFX);

- if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);

- if (!s || (sl && sl < s)) {

- s= strstr(olds, MORPH_TERM_SFX);

- olds = NULL;

- }

- oldt = t;

- tl = strchr(t, '\n');

- t = strstr(t, MORPH_DERI_SFX);

- if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);

- if (!t || (tl && tl < t)) {

- t = strstr(oldt, MORPH_TERM_SFX);

- oldt = NULL;

- }

- while (s && t && (!sl || sl > s) && (!tl || tl > t)) {

- s += MORPH_TAG_LEN;

- t += MORPH_TAG_LEN;

- se = 0;

- te = 0;

- while ((*s == *t) && !se && !te) {

- s++;

- t++;

- switch(*s) {

- case ' ':

- case '\n':

- case '\t':

- case '\0': se = 1;

- }

- switch(*t) {

- case ' ':

- case '\n':

- case '\t':

- case '\0': te = 1;

- }

- if (!se || !te) {

- // not terminal suffix difference

- if (olds) return -1;

- return 1;

- }

- olds = s;

- s = strstr(s, MORPH_DERI_SFX);

- if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);

- if (!s || (sl && sl < s)) {

- s = strstr(olds, MORPH_TERM_SFX);

- olds = NULL;

- }

- oldt = t;

- t = strstr(t, MORPH_DERI_SFX);

- if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);

- if (!t || (tl && tl < t)) {

- t = strstr(oldt, MORPH_TERM_SFX);

- oldt = NULL;

- }

- if (!s && !t && se && te) return 0;

- return 1;

+bool copy_field(std::string& dest,

+ const std::string& morph,

+ const std::string& var) {

+ if (morph.empty())

+ return false;

+ size_t pos = morph.find(var);

+ if (pos == std::string::npos)

+ return false;

+ dest.clear();

+ std::string beg(morph.substr(pos + MORPH_TAG_LEN, std::string::npos));

+ for (size_t i = 0; i < beg.size(); ++i) {

+ const char c(beg[i]);

+ if (c == ' ' || c == '\t' || c == '\n')

+ break;

+ dest.push_back(c);

+ }

+ return true;

}

-int get_sfxcount(const char * morph)

- if (!morph || !*morph) return 0;

- int n = 0;

- const char * old = morph;

- morph = strstr(morph, MORPH_DERI_SFX);

- if (!morph) morph = strstr(old, MORPH_INFL_SFX);

- if (!morph) morph = strstr(old, MORPH_TERM_SFX);

- while (morph) {

- n++;

- old = morph;

- morph = strstr(morph + 1, MORPH_DERI_SFX);

- if (!morph) morph = strstr(old + 1, MORPH_INFL_SFX);

- if (!morph) morph = strstr(old + 1, MORPH_TERM_SFX);

- }

- return n;

+std::string& mystrrep(std::string& str,

+ const std::string& search,

+ const std::string& replace) {

+ size_t pos = 0;

+ while ((pos = str.find(search, pos)) != std::string::npos) {

+ str.replace(pos, search.length(), replace);

+ pos += replace.length();

+ }

+ return str;

}

+// reverse word

+size_t reverseword(std::string& word) {

+ std::reverse(word.begin(), word.end());

+ return word.size();

-int fieldlen(const char * r)

- int n = 0;

- while (r && *r != ' ' && *r != '\t' && *r != '\0' && *r != '\n') {

- r++;

- n++;

- }

- return n;

+// reverse word

+size_t reverseword_utf(std::string& word) {

+ std::vector<w_char> w;

+ u8_u16(w, word);

+ std::reverse(w.begin(), w.end());

+ u16_u8(word, w);

+ return w.size();

}

-char * copy_field(char * dest, const char * morph, const char * var)

- if (!morph) return NULL;

- const char * beg = strstr(morph, var);

- if (beg) {

- char * d = dest;

- for (beg += MORPH_TAG_LEN; *beg != ' ' && *beg != '\t' &&

- *beg != '\n' && *beg != '\0'; d++, beg++) {

- *d = *beg;

- }

- *d = '\0';

- return dest;

+void uniqlist(std::vector<std::string>& list) {

+ if (list.size() < 2)

+ return;

+ std::vector<std::string> ret;

+ ret.push_back(list[0]);

+ for (size_t i = 1; i < list.size(); ++i) {

+ if (std::find(ret.begin(), ret.end(), list[i]) == ret.end())

+ ret.push_back(list[i]);

}

- return NULL;

+ list.swap(ret);

}

-char * mystrrep(char * word, const char * pat, const char * rep) {

- char * pos = strstr(word, pat);

- if (pos) {

- int replen = strlen(rep);

- int patlen = strlen(pat);

- while (pos) {

- if (replen < patlen) {

- char * end = word + strlen(word);

- char * next = pos + replen;

- char * prev = pos + strlen(pat);

- for (; prev < end; *next = *prev, prev++, next++);

- *next = '\0';

- } else if (replen > patlen) {

- char * end = pos + patlen;

- char * next = word + strlen(word) + replen - patlen;

- char * prev = next - replen + patlen;

- for (; prev >= end; *next = *prev, prev--, next--);

- }

- strncpy(pos, rep, replen);

- pos = strstr(word, pat);

- }

- return word;

+namespace {

+unsigned char cupper(const struct cs_info* csconv, int nIndex) {

+ if (nIndex < 0 || nIndex > 255)

+ return nIndex;

+ return csconv[nIndex].cupper;

}

- // reverse word

- int reverseword(char * word) {

- char r;

- for (char * dest = word + strlen(word) - 1; word < dest; word++, dest--) {

- r=*word;

- *word = *dest;

- *dest = r;

- }

- return 0;

- }

+unsigned char clower(const struct cs_info* csconv, int nIndex) {

+ if (nIndex < 0 || nIndex > 255)

+ return nIndex;

+ return csconv[nIndex].clower;

- // reverse word (error: 1)

- int reverseword_utf(char * word) {

- w_char w[MAXWORDLEN];

- w_char * p;

- w_char r;

- int l = u8_u16(w, MAXWORDLEN, word);

- if (l == -1) return 1;

- p = w;

- for (w_char * dest = w + l - 1; p < dest; p++, dest--) {

- r=*p;

- *p = *dest;

- *dest = r;

- }

- u16_u8(word, MAXWORDUTF8LEN, w, l);

- return 0;

- }

+unsigned char ccase(const struct cs_info* csconv, int nIndex) {

+ if (nIndex < 0 || nIndex > 255)

+ return nIndex;

+ return csconv[nIndex].ccase;

- int uniqlist(char ** list, int n) {

- int i;

- if (n < 2) return n;

- for (i = 0; i < n; i++) {

- for (int j = 0; j < i; j++) {

- if (list[j] && list[i] && (strcmp(list[j], list[i]) == 0)) {

- free(list[i]);

- list[i] = NULL;

- break;

- }

- int m = 1;

- for (i = 1; i < n; i++) if (list[i]) {

- list[m] = list[i];

- m++;

+w_char upper_utf(w_char u, int langnum) {

+ unsigned short idx = (u.h << 8) + u.l;

+ if (idx != unicodetoupper(idx, langnum)) {

+ u.h = (unsigned char)(unicodetoupper(idx, langnum) >> 8);

+ u.l = (unsigned char)(unicodetoupper(idx, langnum) & 0x00FF);

+ }

+ return u;

+w_char lower_utf(w_char u, int langnum) {

+ unsigned short idx = (u.h << 8) + u.l;

+ if (idx != unicodetolower(idx, langnum)) {

+ u.h = (unsigned char)(unicodetolower(idx, langnum) >> 8);

+ u.l = (unsigned char)(unicodetolower(idx, langnum) & 0x00FF);

+ }

+ return u;

+// convert std::string to all caps

+std::string& mkallcap(std::string& s, const struct cs_info* csconv) {

+ for (std::string::iterator aI = s.begin(), aEnd = s.end(); aI != aEnd; ++aI) {

+ *aI = cupper(csconv, static_cast<unsigned char>(*aI));

+ }

+ return s;

+// convert std::string to all little

+std::string& mkallsmall(std::string& s, const struct cs_info* csconv) {

+ for (std::string::iterator aI = s.begin(), aEnd = s.end(); aI != aEnd; ++aI) {

+ *aI = clower(csconv, static_cast<unsigned char>(*aI));

+ }

+ return s;

+std::vector<w_char>& mkallsmall_utf(std::vector<w_char>& u,

+ int langnum) {

+ for (size_t i = 0; i < u.size(); ++i) {

+ unsigned short idx = (u[i].h << 8) + u[i].l;

+ if (idx != unicodetolower(idx, langnum)) {

+ u[i].h = (unsigned char)(unicodetolower(idx, langnum) >> 8);

+ u[i].l = (unsigned char)(unicodetolower(idx, langnum) & 0x00FF);

}

- return m;

- }

- void freelist(char *** list, int n) {

- if (list && *list && n > 0) {

- for (int i = 0; i < n; i++) if ((*list)[i]) free((*list)[i]);

- free(*list);

- *list = NULL;

- }

- // convert null terminated string to all caps

- void mkallcap(char * p, const struct cs_info * csconv)

- {

- while (*p != '\0') {

- *p = csconv[((unsigned char) *p)].cupper;

- p++;

- }

- // convert null terminated string to all little

- void mkallsmall(char * p, const struct cs_info * csconv)

- {

- while (*p != '\0') {

- *p = csconv[((unsigned char) *p)].clower;

- p++;

- }

+ }

+ return u;

-void mkallsmall_utf(w_char * u, int nc, int langnum) {

- for (int i = 0; i < nc; i++) {

- unsigned short idx = (u[i].h << 8) + u[i].l;

- if (idx != unicodetolower(idx, langnum)) {

- u[i].h = (unsigned char) (unicodetolower(idx, langnum) >> 8);

- u[i].l = (unsigned char) (unicodetolower(idx, langnum) & 0x00FF);

- }

+std::vector<w_char>& mkallcap_utf(std::vector<w_char>& u, int langnum) {

+ for (size_t i = 0; i < u.size(); i++) {

+ unsigned short idx = (u[i].h << 8) + u[i].l;

+ if (idx != unicodetoupper(idx, langnum)) {

+ u[i].h = (unsigned char)(unicodetoupper(idx, langnum) >> 8);

+ u[i].l = (unsigned char)(unicodetoupper(idx, langnum) & 0x00FF);

}

+ }

+ return u;

}

-void mkallcap_utf(w_char * u, int nc, int langnum) {

- for (int i = 0; i < nc; i++) {

- unsigned short idx = (u[i].h << 8) + u[i].l;

- if (idx != unicodetoupper(idx, langnum)) {

- u[i].h = (unsigned char) (unicodetoupper(idx, langnum) >> 8);

- u[i].l = (unsigned char) (unicodetoupper(idx, langnum) & 0x00FF);

- }

+std::string& mkinitcap(std::string& s, const struct cs_info* csconv) {

+ if (!s.empty()) {

+ s[0] = cupper(csconv, static_cast<unsigned char>(s[0]));

+ }

+ return s;

+std::vector<w_char>& mkinitcap_utf(std::vector<w_char>& u, int langnum) {

+ if (!u.empty()) {

+ unsigned short idx = (u[0].h << 8) + u[0].l;

+ if (idx != unicodetoupper(idx, langnum)) {

+ u[0].h = (unsigned char)(unicodetoupper(idx, langnum) >> 8);

+ u[0].l = (unsigned char)(unicodetoupper(idx, langnum) & 0x00FF);

}

+ }

+ return u;

}

- // convert null terminated string to have initial capital

- void mkinitcap(char * p, const struct cs_info * csconv)

- {

- if (*p != '\0') *p = csconv[((unsigned char)*p)].cupper;

- }

- // conversion function for protected memory

- void store_pointer(char * dest, char * source)

- {

- memcpy(dest, &source, sizeof(char *));

- }

+std::string& mkinitsmall(std::string& s, const struct cs_info* csconv) {

+ if (!s.empty()) {

+ s[0] = clower(csconv, static_cast<unsigned char>(s[0]));

+ }

+ return s;

- // conversion function for protected memory

- char * get_stored_pointer(const char * s)

- {

- char * p;

- memcpy(&p, s, sizeof(char *));

- return p;

- }

+std::vector<w_char>& mkinitsmall_utf(std::vector<w_char>& u, int langnum) {

+ if (!u.empty()) {

+ unsigned short idx = (u[0].h << 8) + u[0].l;

+ if (idx != unicodetolower(idx, langnum)) {

+ u[0].h = (unsigned char)(unicodetolower(idx, langnum) >> 8);

+ u[0].l = (unsigned char)(unicodetolower(idx, langnum) & 0x00FF);

+ }

+ return u;

-#ifndef MOZILLA_CLIENT

- // convert null terminated string to all caps using encoding

- void enmkallcap(char * d, const char * p, const char * encoding)

- {

- struct cs_info * csconv = get_current_cs(encoding);

- while (*p != '\0') {

- *d++ = csconv[((unsigned char) *p)].cupper;

- p++;

- }

- *d = '\0';

- }

+// conversion function for protected memory

+void store_pointer(char* dest, char* source) {

+ memcpy(dest, &source, sizeof(char*));

- // convert null terminated string to all little using encoding

- void enmkallsmall(char * d, const char * p, const char * encoding)

- {

- struct cs_info * csconv = get_current_cs(encoding);

- while (*p != '\0') {

- *d++ = csconv[((unsigned char) *p)].clower;

- p++;

- }

- *d = '\0';

- }

+// conversion function for protected memory

+char* get_stored_pointer(const char* s) {

+ char* p;

+ memcpy(&p, s, sizeof(char*));

+ return p;

- // convert null terminated string to have initial capital using encoding

- void enmkinitcap(char * d, const char * p, const char * encoding)

- {

- struct cs_info * csconv = get_current_cs(encoding);

- memcpy(d,p,(strlen(p)+1));

- if (*p != '\0') *d= csconv[((unsigned char)*p)].cupper;

- }

+#ifndef MOZILLA_CLIENT

-// these are simple character mappings for the

+// these are simple character mappings for the

// encodings supported

// supplying isupper, tolower, and toupper

static struct cs_info iso1_tbl[] = {

-{ 0x00, 0x00, 0x00 },

-{ 0x00, 0x01, 0x01 },

-{ 0x00, 0x02, 0x02 },

-{ 0x00, 0x03, 0x03 },

-{ 0x00, 0x04, 0x04 },

-{ 0x00, 0x05, 0x05 },

-{ 0x00, 0x06, 0x06 },

-{ 0x00, 0x07, 0x07 },

-{ 0x00, 0x08, 0x08 },

-{ 0x00, 0x09, 0x09 },

-{ 0x00, 0x0a, 0x0a },

-{ 0x00, 0x0b, 0x0b },

-{ 0x00, 0x0c, 0x0c },

-{ 0x00, 0x0d, 0x0d },

-{ 0x00, 0x0e, 0x0e },

-{ 0x00, 0x0f, 0x0f },

-{ 0x00, 0x10, 0x10 },

-{ 0x00, 0x11, 0x11 },

-{ 0x00, 0x12, 0x12 },

-{ 0x00, 0x13, 0x13 },

-{ 0x00, 0x14, 0x14 },

-{ 0x00, 0x15, 0x15 },

-{ 0x00, 0x16, 0x16 },

-{ 0x00, 0x17, 0x17 },

-{ 0x00, 0x18, 0x18 },

-{ 0x00, 0x19, 0x19 },

-{ 0x00, 0x1a, 0x1a },

-{ 0x00, 0x1b, 0x1b },

-{ 0x00, 0x1c, 0x1c },

-{ 0x00, 0x1d, 0x1d },

-{ 0x00, 0x1e, 0x1e },

-{ 0x00, 0x1f, 0x1f },

-{ 0x00, 0x20, 0x20 },

-{ 0x00, 0x21, 0x21 },

-{ 0x00, 0x22, 0x22 },

-{ 0x00, 0x23, 0x23 },

-{ 0x00, 0x24, 0x24 },

-{ 0x00, 0x25, 0x25 },

-{ 0x00, 0x26, 0x26 },

-{ 0x00, 0x27, 0x27 },

-{ 0x00, 0x28, 0x28 },

-{ 0x00, 0x29, 0x29 },

-{ 0x00, 0x2a, 0x2a },

-{ 0x00, 0x2b, 0x2b },

-{ 0x00, 0x2c, 0x2c },

-{ 0x00, 0x2d, 0x2d },

-{ 0x00, 0x2e, 0x2e },

-{ 0x00, 0x2f, 0x2f },

-{ 0x00, 0x30, 0x30 },

-{ 0x00, 0x31, 0x31 },

-{ 0x00, 0x32, 0x32 },

-{ 0x00, 0x33, 0x33 },

-{ 0x00, 0x34, 0x34 },

-{ 0x00, 0x35, 0x35 },

-{ 0x00, 0x36, 0x36 },

-{ 0x00, 0x37, 0x37 },

-{ 0x00, 0x38, 0x38 },

-{ 0x00, 0x39, 0x39 },

-{ 0x00, 0x3a, 0x3a },

-{ 0x00, 0x3b, 0x3b },

-{ 0x00, 0x3c, 0x3c },

-{ 0x00, 0x3d, 0x3d },

-{ 0x00, 0x3e, 0x3e },

-{ 0x00, 0x3f, 0x3f },

-{ 0x00, 0x40, 0x40 },

-{ 0x01, 0x61, 0x41 },

-{ 0x01, 0x62, 0x42 },

-{ 0x01, 0x63, 0x43 },

-{ 0x01, 0x64, 0x44 },

-{ 0x01, 0x65, 0x45 },

-{ 0x01, 0x66, 0x46 },

-{ 0x01, 0x67, 0x47 },

-{ 0x01, 0x68, 0x48 },

-{ 0x01, 0x69, 0x49 },

-{ 0x01, 0x6a, 0x4a },

-{ 0x01, 0x6b, 0x4b },

-{ 0x01, 0x6c, 0x4c },

-{ 0x01, 0x6d, 0x4d },

-{ 0x01, 0x6e, 0x4e },

-{ 0x01, 0x6f, 0x4f },

-{ 0x01, 0x70, 0x50 },

-{ 0x01, 0x71, 0x51 },

-{ 0x01, 0x72, 0x52 },

-{ 0x01, 0x73, 0x53 },

-{ 0x01, 0x74, 0x54 },

-{ 0x01, 0x75, 0x55 },

-{ 0x01, 0x76, 0x56 },

-{ 0x01, 0x77, 0x57 },

-{ 0x01, 0x78, 0x58 },

-{ 0x01, 0x79, 0x59 },

-{ 0x01, 0x7a, 0x5a },

-{ 0x00, 0x5b, 0x5b },

-{ 0x00, 0x5c, 0x5c },

-{ 0x00, 0x5d, 0x5d },

-{ 0x00, 0x5e, 0x5e },

-{ 0x00, 0x5f, 0x5f },

-{ 0x00, 0x60, 0x60 },

-{ 0x00, 0x61, 0x41 },

-{ 0x00, 0x62, 0x42 },

-{ 0x00, 0x63, 0x43 },

-{ 0x00, 0x64, 0x44 },

-{ 0x00, 0x65, 0x45 },

-{ 0x00, 0x66, 0x46 },

-{ 0x00, 0x67, 0x47 },

-{ 0x00, 0x68, 0x48 },

-{ 0x00, 0x69, 0x49 },

-{ 0x00, 0x6a, 0x4a },

-{ 0x00, 0x6b, 0x4b },

-{ 0x00, 0x6c, 0x4c },

-{ 0x00, 0x6d, 0x4d },

-{ 0x00, 0x6e, 0x4e },

-{ 0x00, 0x6f, 0x4f },

-{ 0x00, 0x70, 0x50 },

-{ 0x00, 0x71, 0x51 },

-{ 0x00, 0x72, 0x52 },

-{ 0x00, 0x73, 0x53 },

-{ 0x00, 0x74, 0x54 },

-{ 0x00, 0x75, 0x55 },

-{ 0x00, 0x76, 0x56 },

-{ 0x00, 0x77, 0x57 },

-{ 0x00, 0x78, 0x58 },

-{ 0x00, 0x79, 0x59 },

-{ 0x00, 0x7a, 0x5a },

-{ 0x00, 0x7b, 0x7b },

-{ 0x00, 0x7c, 0x7c },

-{ 0x00, 0x7d, 0x7d },

-{ 0x00, 0x7e, 0x7e },

-{ 0x00, 0x7f, 0x7f },

-{ 0x00, 0x80, 0x80 },

-{ 0x00, 0x81, 0x81 },

-{ 0x00, 0x82, 0x82 },

-{ 0x00, 0x83, 0x83 },

-{ 0x00, 0x84, 0x84 },

-{ 0x00, 0x85, 0x85 },

-{ 0x00, 0x86, 0x86 },

-{ 0x00, 0x87, 0x87 },

-{ 0x00, 0x88, 0x88 },

-{ 0x00, 0x89, 0x89 },

-{ 0x00, 0x8a, 0x8a },

-{ 0x00, 0x8b, 0x8b },

-{ 0x00, 0x8c, 0x8c },

-{ 0x00, 0x8d, 0x8d },

-{ 0x00, 0x8e, 0x8e },

-{ 0x00, 0x8f, 0x8f },

-{ 0x00, 0x90, 0x90 },

-{ 0x00, 0x91, 0x91 },

-{ 0x00, 0x92, 0x92 },

-{ 0x00, 0x93, 0x93 },

-{ 0x00, 0x94, 0x94 },

-{ 0x00, 0x95, 0x95 },

-{ 0x00, 0x96, 0x96 },

-{ 0x00, 0x97, 0x97 },

-{ 0x00, 0x98, 0x98 },

-{ 0x00, 0x99, 0x99 },

-{ 0x00, 0x9a, 0x9a },

-{ 0x00, 0x9b, 0x9b },

-{ 0x00, 0x9c, 0x9c },

-{ 0x00, 0x9d, 0x9d },

-{ 0x00, 0x9e, 0x9e },

-{ 0x00, 0x9f, 0x9f },

-{ 0x00, 0xa0, 0xa0 },

-{ 0x00, 0xa1, 0xa1 },

-{ 0x00, 0xa2, 0xa2 },

-{ 0x00, 0xa3, 0xa3 },

-{ 0x00, 0xa4, 0xa4 },

-{ 0x00, 0xa5, 0xa5 },

-{ 0x00, 0xa6, 0xa6 },

-{ 0x00, 0xa7, 0xa7 },

-{ 0x00, 0xa8, 0xa8 },

-{ 0x00, 0xa9, 0xa9 },

-{ 0x00, 0xaa, 0xaa },

-{ 0x00, 0xab, 0xab },

-{ 0x00, 0xac, 0xac },

-{ 0x00, 0xad, 0xad },

-{ 0x00, 0xae, 0xae },

-{ 0x00, 0xaf, 0xaf },

-{ 0x00, 0xb0, 0xb0 },

-{ 0x00, 0xb1, 0xb1 },

-{ 0x00, 0xb2, 0xb2 },

-{ 0x00, 0xb3, 0xb3 },

-{ 0x00, 0xb4, 0xb4 },

-{ 0x00, 0xb5, 0xb5 },

-{ 0x00, 0xb6, 0xb6 },

-{ 0x00, 0xb7, 0xb7 },

-{ 0x00, 0xb8, 0xb8 },

-{ 0x00, 0xb9, 0xb9 },

-{ 0x00, 0xba, 0xba },

-{ 0x00, 0xbb, 0xbb },

-{ 0x00, 0xbc, 0xbc },

-{ 0x00, 0xbd, 0xbd },

-{ 0x00, 0xbe, 0xbe },

-{ 0x00, 0xbf, 0xbf },

-{ 0x01, 0xe0, 0xc0 },

-{ 0x01, 0xe1, 0xc1 },

-{ 0x01, 0xe2, 0xc2 },

-{ 0x01, 0xe3, 0xc3 },

-{ 0x01, 0xe4, 0xc4 },

-{ 0x01, 0xe5, 0xc5 },

-{ 0x01, 0xe6, 0xc6 },

-{ 0x01, 0xe7, 0xc7 },

-{ 0x01, 0xe8, 0xc8 },

-{ 0x01, 0xe9, 0xc9 },

-{ 0x01, 0xea, 0xca },

-{ 0x01, 0xeb, 0xcb },

-{ 0x01, 0xec, 0xcc },

-{ 0x01, 0xed, 0xcd },

-{ 0x01, 0xee, 0xce },

-{ 0x01, 0xef, 0xcf },

-{ 0x01, 0xf0, 0xd0 },

-{ 0x01, 0xf1, 0xd1 },

-{ 0x01, 0xf2, 0xd2 },

-{ 0x01, 0xf3, 0xd3 },

-{ 0x01, 0xf4, 0xd4 },

-{ 0x01, 0xf5, 0xd5 },

-{ 0x01, 0xf6, 0xd6 },

-{ 0x00, 0xd7, 0xd7 },

-{ 0x01, 0xf8, 0xd8 },

-{ 0x01, 0xf9, 0xd9 },

-{ 0x01, 0xfa, 0xda },

-{ 0x01, 0xfb, 0xdb },

-{ 0x01, 0xfc, 0xdc },

-{ 0x01, 0xfd, 0xdd },

-{ 0x01, 0xfe, 0xde },

-{ 0x00, 0xdf, 0xdf },

-{ 0x00, 0xe0, 0xc0 },

-{ 0x00, 0xe1, 0xc1 },

-{ 0x00, 0xe2, 0xc2 },

-{ 0x00, 0xe3, 0xc3 },

-{ 0x00, 0xe4, 0xc4 },

-{ 0x00, 0xe5, 0xc5 },

-{ 0x00, 0xe6, 0xc6 },

-{ 0x00, 0xe7, 0xc7 },

-{ 0x00, 0xe8, 0xc8 },

-{ 0x00, 0xe9, 0xc9 },

-{ 0x00, 0xea, 0xca },

-{ 0x00, 0xeb, 0xcb },

-{ 0x00, 0xec, 0xcc },

-{ 0x00, 0xed, 0xcd },

-{ 0x00, 0xee, 0xce },

-{ 0x00, 0xef, 0xcf },

-{ 0x00, 0xf0, 0xd0 },

-{ 0x00, 0xf1, 0xd1 },

-{ 0x00, 0xf2, 0xd2 },

-{ 0x00, 0xf3, 0xd3 },

-{ 0x00, 0xf4, 0xd4 },

-{ 0x00, 0xf5, 0xd5 },

-{ 0x00, 0xf6, 0xd6 },

-{ 0x00, 0xf7, 0xf7 },

-{ 0x00, 0xf8, 0xd8 },

-{ 0x00, 0xf9, 0xd9 },

-{ 0x00, 0xfa, 0xda },

-{ 0x00, 0xfb, 0xdb },

-{ 0x00, 0xfc, 0xdc },

-{ 0x00, 0xfd, 0xdd },

-{ 0x00, 0xfe, 0xde },

-{ 0x00, 0xff, 0xff }

-};

+ {0x00, 0x00, 0x00}, {0x00, 0x01, 0x01}, {0x00, 0x02, 0x02},

+ {0x00, 0x03, 0x03}, {0x00, 0x04, 0x04}, {0x00, 0x05, 0x05},

+ {0x00, 0x06, 0x06}, {0x00, 0x07, 0x07}, {0x00, 0x08, 0x08},

+ {0x00, 0x09, 0x09}, {0x00, 0x0a, 0x0a}, {0x00, 0x0b, 0x0b},

+ {0x00, 0x0c, 0x0c}, {0x00, 0x0d, 0x0d}, {0x00, 0x0e, 0x0e},

+ {0x00, 0x0f, 0x0f}, {0x00, 0x10, 0x10}, {0x00, 0x11, 0x11},

+ {0x00, 0x12, 0x12}, {0x00, 0x13, 0x13}, {0x00, 0x14, 0x14},

+ {0x00, 0x15, 0x15}, {0x00, 0x16, 0x16}, {0x00, 0x17, 0x17},

+ {0x00, 0x18, 0x18}, {0x00, 0x19, 0x19}, {0x00, 0x1a, 0x1a},

+ {0x00, 0x1b, 0x1b}, {0x00, 0x1c, 0x1c}, {0x00, 0x1d, 0x1d},

+ {0x00, 0x1e, 0x1e}, {0x00, 0x1f, 0x1f}, {0x00, 0x20, 0x20},

+ {0x00, 0x21, 0x21}, {0x00, 0x22, 0x22}, {0x00, 0x23, 0x23},

+ {0x00, 0x24, 0x24}, {0x00, 0x25, 0x25}, {0x00, 0x26, 0x26},

+ {0x00, 0x27, 0x27}, {0x00, 0x28, 0x28}, {0x00, 0x29, 0x29},

+ {0x00, 0x2a, 0x2a}, {0x00, 0x2b, 0x2b}, {0x00, 0x2c, 0x2c},

+ {0x00, 0x2d, 0x2d}, {0x00, 0x2e, 0x2e}, {0x00, 0x2f, 0x2f},

+ {0x00, 0x30, 0x30}, {0x00, 0x31, 0x31}, {0x00, 0x32, 0x32},

+ {0x00, 0x33, 0x33}, {0x00, 0x34, 0x34}, {0x00, 0x35, 0x35},

+ {0x00, 0x36, 0x36}, {0x00, 0x37, 0x37}, {0x00, 0x38, 0x38},

+ {0x00, 0x39, 0x39}, {0x00, 0x3a, 0x3a}, {0x00, 0x3b, 0x3b},

+ {0x00, 0x3c, 0x3c}, {0x00, 0x3d, 0x3d}, {0x00, 0x3e, 0x3e},

+ {0x00, 0x3f, 0x3f}, {0x00, 0x40, 0x40}, {0x01, 0x61, 0x41},

+ {0x01, 0x62, 0x42}, {0x01, 0x63, 0x43}, {0x01, 0x64, 0x44},

+ {0x01, 0x65, 0x45}, {0x01, 0x66, 0x46}, {0x01, 0x67, 0x47},

+ {0x01, 0x68, 0x48}, {0x01, 0x69, 0x49}, {0x01, 0x6a, 0x4a},

+ {0x01, 0x6b, 0x4b}, {0x01, 0x6c, 0x4c}, {0x01, 0x6d, 0x4d},

+ {0x01, 0x6e, 0x4e}, {0x01, 0x6f, 0x4f}, {0x01, 0x70, 0x50},

+ {0x01, 0x71, 0x51}, {0x01, 0x72, 0x52}, {0x01, 0x73, 0x53},

+ {0x01, 0x74, 0x54}, {0x01, 0x75, 0x55}, {0x01, 0x76, 0x56},

+ {0x01, 0x77, 0x57}, {0x01, 0x78, 0x58}, {0x01, 0x79, 0x59},

+ {0x01, 0x7a, 0x5a}, {0x00, 0x5b, 0x5b}, {0x00, 0x5c, 0x5c},

+ {0x00, 0x5d, 0x5d}, {0x00, 0x5e, 0x5e}, {0x00, 0x5f, 0x5f},

+ {0x00, 0x60, 0x60}, {0x00, 0x61, 0x41}, {0x00, 0x62, 0x42},

+ {0x00, 0x63, 0x43}, {0x00, 0x64, 0x44}, {0x00, 0x65, 0x45},

+ {0x00, 0x66, 0x46}, {0x00, 0x67, 0x47}, {0x00, 0x68, 0x48},

+ {0x00, 0x69, 0x49}, {0x00, 0x6a, 0x4a}, {0x00, 0x6b, 0x4b},

+ {0x00, 0x6c, 0x4c}, {0x00, 0x6d, 0x4d}, {0x00, 0x6e, 0x4e},

+ {0x00, 0x6f, 0x4f}, {0x00, 0x70, 0x50}, {0x00, 0x71, 0x51},

+ {0x00, 0x72, 0x52}, {0x00, 0x73, 0x53}, {0x00, 0x74, 0x54},

+ {0x00, 0x75, 0x55}, {0x00, 0x76, 0x56}, {0x00, 0x77, 0x57},

+ {0x00, 0x78, 0x58}, {0x00, 0x79, 0x59}, {0x00, 0x7a, 0x5a},

+ {0x00, 0x7b, 0x7b}, {0x00, 0x7c, 0x7c}, {0x00, 0x7d, 0x7d},

+ {0x00, 0x7e, 0x7e}, {0x00, 0x7f, 0x7f}, {0x00, 0x80, 0x80},

+ {0x00, 0x81, 0x81}, {0x00, 0x82, 0x82}, {0x00, 0x83, 0x83},

+ {0x00, 0x84, 0x84}, {0x00, 0x85, 0x85}, {0x00, 0x86, 0x86},

+ {0x00, 0x87, 0x87}, {0x00, 0x88, 0x88}, {0x00, 0x89, 0x89},

+ {0x00, 0x8a, 0x8a}, {0x00, 0x8b, 0x8b}, {0x00, 0x8c, 0x8c},

+ {0x00, 0x8d, 0x8d}, {0x00, 0x8e, 0x8e}, {0x00, 0x8f, 0x8f},

+ {0x00, 0x90, 0x90}, {0x00, 0x91, 0x91}, {0x00, 0x92, 0x92},

+ {0x00, 0x93, 0x93}, {0x00, 0x94, 0x94}, {0x00, 0x95, 0x95},

+ {0x00, 0x96, 0x96}, {0x00, 0x97, 0x97}, {0x00, 0x98, 0x98},

+ {0x00, 0x99, 0x99}, {0x00, 0x9a, 0x9a}, {0x00, 0x9b, 0x9b},

+ {0x00, 0x9c, 0x9c}, {0x00, 0x9d, 0x9d}, {0x00, 0x9e, 0x9e},

+ {0x00, 0x9f, 0x9f}, {0x00, 0xa0, 0xa0}, {0x00, 0xa1, 0xa1},

+ {0x00, 0xa2, 0xa2}, {0x00, 0xa3, 0xa3}, {0x00, 0xa4, 0xa4},

+ {0x00, 0xa5, 0xa5}, {0x00, 0xa6, 0xa6}, {0x00, 0xa7, 0xa7},

+ {0x00, 0xa8, 0xa8}, {0x00, 0xa9, 0xa9}, {0x00, 0xaa, 0xaa},

+ {0x00, 0xab, 0xab}, {0x00, 0xac, 0xac}, {0x00, 0xad, 0xad},

+ {0x00, 0xae, 0xae}, {0x00, 0xaf, 0xaf}, {0x00, 0xb0, 0xb0},

+ {0x00, 0xb1, 0xb1}, {0x00, 0xb2, 0xb2}, {0x00, 0xb3, 0xb3},

+ {0x00, 0xb4, 0xb4}, {0x00, 0xb5, 0xb5}, {0x00, 0xb6, 0xb6},

+ {0x00, 0xb7, 0xb7}, {0x00, 0xb8, 0xb8}, {0x00, 0xb9, 0xb9},

+ {0x00, 0xba, 0xba}, {0x00, 0xbb, 0xbb}, {0x00, 0xbc, 0xbc},

+ {0x00, 0xbd, 0xbd}, {0x00, 0xbe, 0xbe}, {0x00, 0xbf, 0xbf},

+ {0x01, 0xe0, 0xc0}, {0x01, 0xe1, 0xc1}, {0x01, 0xe2, 0xc2},

+ {0x01, 0xe3, 0xc3}, {0x01, 0xe4, 0xc4}, {0x01, 0xe5, 0xc5},

+ {0x01, 0xe6, 0xc6}, {0x01, 0xe7, 0xc7}, {0x01, 0xe8, 0xc8},

+ {0x01, 0xe9, 0xc9}, {0x01, 0xea, 0xca}, {0x01, 0xeb, 0xcb},

+ {0x01, 0xec, 0xcc}, {0x01, 0xed, 0xcd}, {0x01, 0xee, 0xce},

+ {0x01, 0xef, 0xcf}, {0x01, 0xf0, 0xd0}, {0x01, 0xf1, 0xd1},

+ {0x01, 0xf2, 0xd2}, {0x01, 0xf3, 0xd3}, {0x01, 0xf4, 0xd4},

+ {0x01, 0xf5, 0xd5}, {0x01, 0xf6, 0xd6}, {0x00, 0xd7, 0xd7},

+ {0x01, 0xf8, 0xd8}, {0x01, 0xf9, 0xd9}, {0x01, 0xfa, 0xda},

+ {0x01, 0xfb, 0xdb}, {0x01, 0xfc, 0xdc}, {0x01, 0xfd, 0xdd},

+ {0x01, 0xfe, 0xde}, {0x00, 0xdf, 0xdf}, {0x00, 0xe0, 0xc0},

+ {0x00, 0xe1, 0xc1}, {0x00, 0xe2, 0xc2}, {0x00, 0xe3, 0xc3},

+ {0x00, 0xe4, 0xc4}, {0x00, 0xe5, 0xc5}, {0x00, 0xe6, 0xc6},

+ {0x00, 0xe7, 0xc7}, {0x00, 0xe8, 0xc8}, {0x00, 0xe9, 0xc9},

+ {0x00, 0xea, 0xca}, {0x00, 0xeb, 0xcb}, {0x00, 0xec, 0xcc},

+ {0x00, 0xed, 0xcd}, {0x00, 0xee, 0xce}, {0x00, 0xef, 0xcf},

+ {0x00, 0xf0, 0xd0}, {0x00, 0xf1, 0xd1}, {0x00, 0xf2, 0xd2},

+ {0x00, 0xf3, 0xd3}, {0x00, 0xf4, 0xd4}, {0x00, 0xf5, 0xd5},

+ {0x00, 0xf6, 0xd6}, {0x00, 0xf7, 0xf7}, {0x00, 0xf8, 0xd8},

+ {0x00, 0xf9, 0xd9}, {0x00, 0xfa, 0xda}, {0x00, 0xfb, 0xdb},

+ {0x00, 0xfc, 0xdc}, {0x00, 0xfd, 0xdd}, {0x00, 0xfe, 0xde},

+ {0x00, 0xff, 0xff}};

static struct cs_info iso2_tbl[] = {

-{ 0x00, 0x00, 0x00 },

-{ 0x00, 0x01, 0x01 },

-{ 0x00, 0x02, 0x02 },

-{ 0x00, 0x03, 0x03 },

-{ 0x00, 0x04, 0x04 },

-{ 0x00, 0x05, 0x05 },

-{ 0x00, 0x06, 0x06 },

-{ 0x00, 0x07, 0x07 },

-{ 0x00, 0x08, 0x08 },

-{ 0x00, 0x09, 0x09 },

-{ 0x00, 0x0a, 0x0a },

-{ 0x00, 0x0b, 0x0b },

-{ 0x00, 0x0c, 0x0c },

-{ 0x00, 0x0d, 0x0d },

-{ 0x00, 0x0e, 0x0e },

-{ 0x00, 0x0f, 0x0f },

-{ 0x00, 0x10, 0x10 },

-{ 0x00, 0x11, 0x11 },

-{ 0x00, 0x12, 0x12 },

-{ 0x00, 0x13, 0x13 },

-{ 0x00, 0x14, 0x14 },

-{ 0x00, 0x15, 0x15 },

-{ 0x00, 0x16, 0x16 },

-{ 0x00, 0x17, 0x17 },

-{ 0x00, 0x18, 0x18 },

-{ 0x00, 0x19, 0x19 },

-{ 0x00, 0x1a, 0x1a },

-{ 0x00, 0x1b, 0x1b },

-{ 0x00, 0x1c, 0x1c },

-{ 0x00, 0x1d, 0x1d },

-{ 0x00, 0x1e, 0x1e },

-{ 0x00, 0x1f, 0x1f },

-{ 0x00, 0x20, 0x20 },

-{ 0x00, 0x21, 0x21 },

-{ 0x00, 0x22, 0x22 },

-{ 0x00, 0x23, 0x23 },

-{ 0x00, 0x24, 0x24 },

-{ 0x00, 0x25, 0x25 },

-{ 0x00, 0x26, 0x26 },

-{ 0x00, 0x27, 0x27 },

-{ 0x00, 0x28, 0x28 },

-{ 0x00, 0x29, 0x29 },

-{ 0x00, 0x2a, 0x2a },

-{ 0x00, 0x2b, 0x2b },

-{ 0x00, 0x2c, 0x2c },

-{ 0x00, 0x2d, 0x2d },

-{ 0x00, 0x2e, 0x2e },

-{ 0x00, 0x2f, 0x2f },

-{ 0x00, 0x30, 0x30 },

-{ 0x00, 0x31, 0x31 },

-{ 0x00, 0x32, 0x32 },

-{ 0x00, 0x33, 0x33 },

-{ 0x00, 0x34, 0x34 },

-{ 0x00, 0x35, 0x35 },

-{ 0x00, 0x36, 0x36 },

-{ 0x00, 0x37, 0x37 },

-{ 0x00, 0x38, 0x38 },

-{ 0x00, 0x39, 0x39 },

-{ 0x00, 0x3a, 0x3a },

-{ 0x00, 0x3b, 0x3b },

-{ 0x00, 0x3c, 0x3c },

-{ 0x00, 0x3d, 0x3d },

-{ 0x00, 0x3e, 0x3e },

-{ 0x00, 0x3f, 0x3f },

-{ 0x00, 0x40, 0x40 },

-{ 0x01, 0x61, 0x41 },

-{ 0x01, 0x62, 0x42 },

-{ 0x01, 0x63, 0x43 },

-{ 0x01, 0x64, 0x44 },

-{ 0x01, 0x65, 0x45 },

-{ 0x01, 0x66, 0x46 },

-{ 0x01, 0x67, 0x47 },

-{ 0x01, 0x68, 0x48 },

-{ 0x01, 0x69, 0x49 },

-{ 0x01, 0x6a, 0x4a },

-{ 0x01, 0x6b, 0x4b },

-{ 0x01, 0x6c, 0x4c },

-{ 0x01, 0x6d, 0x4d },

-{ 0x01, 0x6e, 0x4e },

-{ 0x01, 0x6f, 0x4f },

-{ 0x01, 0x70, 0x50 },

-{ 0x01, 0x71, 0x51 },

-{ 0x01, 0x72, 0x52 },

-{ 0x01, 0x73, 0x53 },

-{ 0x01, 0x74, 0x54 },

-{ 0x01, 0x75, 0x55 },

-{ 0x01, 0x76, 0x56 },

-{ 0x01, 0x77, 0x57 },

-{ 0x01, 0x78, 0x58 },

-{ 0x01, 0x79, 0x59 },

-{ 0x01, 0x7a, 0x5a },

-{ 0x00, 0x5b, 0x5b },

-{ 0x00, 0x5c, 0x5c },

-{ 0x00, 0x5d, 0x5d },

-{ 0x00, 0x5e, 0x5e },

-{ 0x00, 0x5f, 0x5f },

-{ 0x00, 0x60, 0x60 },

-{ 0x00, 0x61, 0x41 },

-{ 0x00, 0x62, 0x42 },

-{ 0x00, 0x63, 0x43 },

-{ 0x00, 0x64, 0x44 },

-{ 0x00, 0x65, 0x45 },

-{ 0x00, 0x66, 0x46 },

-{ 0x00, 0x67, 0x47 },

-{ 0x00, 0x68, 0x48 },

-{ 0x00, 0x69, 0x49 },

-{ 0x00, 0x6a, 0x4a },

-{ 0x00, 0x6b, 0x4b },

-{ 0x00, 0x6c, 0x4c },

-{ 0x00, 0x6d, 0x4d },

-{ 0x00, 0x6e, 0x4e },

-{ 0x00, 0x6f, 0x4f },

-{ 0x00, 0x70, 0x50 },

-{ 0x00, 0x71, 0x51 },

-{ 0x00, 0x72, 0x52 },

-{ 0x00, 0x73, 0x53 },

-{ 0x00, 0x74, 0x54 },

-{ 0x00, 0x75, 0x55 },

-{ 0x00, 0x76, 0x56 },

-{ 0x00, 0x77, 0x57 },

-{ 0x00, 0x78, 0x58 },

-{ 0x00, 0x79, 0x59 },

-{ 0x00, 0x7a, 0x5a },

-{ 0x00, 0x7b, 0x7b },

-{ 0x00, 0x7c, 0x7c },

-{ 0x00, 0x7d, 0x7d },

-{ 0x00, 0x7e, 0x7e },

-{ 0x00, 0x7f, 0x7f },

-{ 0x00, 0x80, 0x80 },

-{ 0x00, 0x81, 0x81 },

-{ 0x00, 0x82, 0x82 },

-{ 0x00, 0x83, 0x83 },

-{ 0x00, 0x84, 0x84 },

-{ 0x00, 0x85, 0x85 },

-{ 0x00, 0x86, 0x86 },

-{ 0x00, 0x87, 0x87 },

-{ 0x00, 0x88, 0x88 },

-{ 0x00, 0x89, 0x89 },

-{ 0x00, 0x8a, 0x8a },

-{ 0x00, 0x8b, 0x8b },

-{ 0x00, 0x8c, 0x8c },

-{ 0x00, 0x8d, 0x8d },

-{ 0x00, 0x8e, 0x8e },

-{ 0x00, 0x8f, 0x8f },

-{ 0x00, 0x90, 0x90 },

-{ 0x00, 0x91, 0x91 },

-{ 0x00, 0x92, 0x92 },

-{ 0x00, 0x93, 0x93 },

-{ 0x00, 0x94, 0x94 },

-{ 0x00, 0x95, 0x95 },

-{ 0x00, 0x96, 0x96 },

-{ 0x00, 0x97, 0x97 },

-{ 0x00, 0x98, 0x98 },

-{ 0x00, 0x99, 0x99 },

-{ 0x00, 0x9a, 0x9a },

-{ 0x00, 0x9b, 0x9b },

-{ 0x00, 0x9c, 0x9c },

-{ 0x00, 0x9d, 0x9d },

-{ 0x00, 0x9e, 0x9e },

-{ 0x00, 0x9f, 0x9f },

-{ 0x00, 0xa0, 0xa0 },

-{ 0x01, 0xb1, 0xa1 },

-{ 0x00, 0xa2, 0xa2 },

-{ 0x01, 0xb3, 0xa3 },

-{ 0x00, 0xa4, 0xa4 },

-{ 0x01, 0xb5, 0xa5 },

-{ 0x01, 0xb6, 0xa6 },

-{ 0x00, 0xa7, 0xa7 },

-{ 0x00, 0xa8, 0xa8 },

-{ 0x01, 0xb9, 0xa9 },

-{ 0x01, 0xba, 0xaa },

-{ 0x01, 0xbb, 0xab },

-{ 0x01, 0xbc, 0xac },

-{ 0x00, 0xad, 0xad },

-{ 0x01, 0xbe, 0xae },

-{ 0x01, 0xbf, 0xaf },

-{ 0x00, 0xb0, 0xb0 },

-{ 0x00, 0xb1, 0xa1 },

-{ 0x00, 0xb2, 0xb2 },

-{ 0x00, 0xb3, 0xa3 },

-{ 0x00, 0xb4, 0xb4 },

-{ 0x00, 0xb5, 0xa5 },

-{ 0x00, 0xb6, 0xa6 },

-{ 0x00, 0xb7, 0xb7 },

-{ 0x00, 0xb8, 0xb8 },

-{ 0x00, 0xb9, 0xa9 },

-{ 0x00, 0xba, 0xaa },

-{ 0x00, 0xbb, 0xab },

-{ 0x00, 0xbc, 0xac },

-{ 0x00, 0xbd, 0xbd },

-{ 0x00, 0xbe, 0xae },

-{ 0x00, 0xbf, 0xaf },