Index: psqlodbc/convert.c diff -c psqlodbc/convert.c:1.1.1.5 psqlodbc/convert.c:1.1.1.5.2.1 *** psqlodbc/convert.c:1.1.1.5 Fri Jul 13 20:24:05 2001 --- psqlodbc/convert.c Fri Jul 13 23:05:07 2001 *************** *** 51,56 **** --- 51,59 ---- #include "pgtypes.h" #include "lobj.h" #include "connection.h" + #ifdef KANJI + #include "kanji.h" + #endif /* KANJI */ #ifndef WIN32 #ifndef HAVE_STRICMP *************** *** 193,198 **** --- 196,204 ---- BOOL changed; static char *tempBuf= NULL; static unsigned int tempBuflen = 0; + #ifdef KANJI + char *kanji_value = NULL; + #endif /* KANJI */ if (!tempBuf) tempBuflen = 0; *************** *** 445,450 **** --- 451,465 ---- stmt->bindings[stmt->current_col].data_left = (cbValueMax > 0) ? 0 : -1; /* This seems to be needed for ADO ? */ if (stmt->current_col < 0 || stmt->bindings[stmt->current_col].data_left < 0) { + #ifdef KANJI + kanji_value = euc_to_sjis( (char *) value, SQL_NTS); + if ( ! kanji_value) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + return COPY_GENERAL_ERROR; + } + value = kanji_value; + #endif /* KANJI */ /* convert linefeeds to carriage-return/linefeed */ len = convert_linefeeds(value, NULL, 0, &changed); if (cbValueMax == 0) /* just returns length info */ *************** *** 486,491 **** --- 501,513 ---- free(tempBuf); tempBuf = NULL; } + #ifdef KANJI + if (kanji_value) + { + free(kanji_value); + kanji_value = NULL; + } + #endif /* KANJI */ /* The following seems to be needed for ADO ? */ stmt->bindings[stmt->current_col].data_left = -2; return COPY_NO_DATA_FOUND; *************** *** 527,532 **** --- 549,561 ---- } } + #ifdef KANJI + if (kanji_value) + { + free(kanji_value); + kanji_value = NULL; + } + #endif /* KANJI */ mylog(" SQL_C_CHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow); break; *************** *** 1323,1329 **** --- 1352,1372 ---- /* it was a SQL_C_CHAR */ if (buf) { + #ifdef KANJI + { + char *kanji = sjis_to_euc(buf, used); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + CVT_SPECIAL_CHARS(kanji, SQL_NTS); + free(kanji); + } + #else /* KANJI */ CVT_SPECIAL_CHARS(buf, used); + #endif /* KANJI */ } /* it was a numeric type */ Index: psqlodbc/execute.c diff -c psqlodbc/execute.c:1.1.1.5 psqlodbc/execute.c:1.1.1.5.2.1 *** psqlodbc/execute.c:1.1.1.5 Fri Jul 13 20:24:09 2001 --- psqlodbc/execute.c Fri Jul 13 23:05:08 2001 *************** *** 36,41 **** --- 36,44 ---- #include "bind.h" #include "pgtypes.h" #include "lobj.h" + #ifdef KANJI + #include "kanji.h" + #endif /* KANJI */ extern GLOBAL_VALUES globals; *************** *** 113,118 **** --- 116,134 ---- SC_log_error(func, "", self); return SQL_ERROR; } + #ifdef KANJI + { + char *kanji = sjis_to_euc(self->statement, SQL_NTS); + if ( ! kanji) { + self->errornumber = STMT_NO_MEMORY_ERROR; + self->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", self); + return SQL_ERROR; + } + free(self->statement); + self->statement = kanji; + } + #endif /* KANJI */ self->prepare = TRUE; self->statement_type = statement_type(self->statement); *************** *** 164,169 **** --- 180,198 ---- SC_log_error(func, "", stmt); return SQL_ERROR; } + #ifdef KANJI + { + char *kanji = sjis_to_euc(stmt->statement, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + free(stmt->statement); + stmt->statement = kanji; + } + #endif /* KANJI */ mylog("**** %s: hstmt=%u, statement='%s'\n", func, hstmt, stmt->statement); Index: psqlodbc/info.c diff -c psqlodbc/info.c:1.1.1.5 psqlodbc/info.c:1.1.1.5.2.1 *** psqlodbc/info.c:1.1.1.5 Fri Jul 13 20:24:11 2001 --- psqlodbc/info.c Fri Jul 13 23:05:09 2001 *************** *** 45,50 **** --- 45,53 ---- #include "bind.h" #include "misc.h" #include "pgtypes.h" + #ifdef KANJI + #include "kanji.h" + #endif /* KANJI */ /* Trigger related stuff for SQLForeign Keys */ *************** *** 1298,1303 **** --- 1301,1334 ---- while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(table_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_name, kanji, sizeof(table_name)); + free(kanji); + + kanji = sjis_to_euc(table_owner, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_owner, kanji, sizeof(table_owner)); + free(kanji); + } + #endif /* KANJI */ + /* * Determine if this table name is a system table. If treating * system tables as regular tables, then no need to do this test. *************** *** 1642,1647 **** --- 1673,1729 ---- result = SQLFetch(hcol_stmt); + + #ifdef KANJI + if ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + char *kanji; + + kanji = sjis_to_euc(table_owner, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_owner, kanji, sizeof(table_owner)); + free(kanji); + + kanji = sjis_to_euc(table_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_name, kanji, sizeof(table_name)); + free(kanji); + + kanji = sjis_to_euc(field_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(field_name, kanji, sizeof(field_name)); + free(kanji); + + kanji = sjis_to_euc(field_type_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(field_type_name, kanji, sizeof(field_type_name)); + free(kanji); + } + #endif /* KANJI */ + /* * Only show oid if option AND there are other columns AND it's not * being called by SQLStatistics . Always show OID if it's a system *************** *** 1777,1782 **** --- 1859,1913 ---- result = SQLFetch(hcol_stmt); + #ifdef KANJI + if ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + char *kanji; + + kanji = sjis_to_euc(table_owner, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_owner, kanji, sizeof(table_owner)); + free(kanji); + + kanji = sjis_to_euc(table_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(table_name, kanji, sizeof(table_name)); + free(kanji); + + kanji = sjis_to_euc(field_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(field_name, kanji, sizeof(field_name)); + free(kanji); + + kanji = sjis_to_euc(field_type_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(field_type_name, kanji, sizeof(field_type_name)); + free(kanji); + } + #endif /* KANJI */ } if (result != SQL_NO_DATA_FOUND) { *************** *** 2018,2023 **** --- 2149,2157 ---- char error = TRUE; ConnInfo *ci; char buf[256]; + #ifdef KANJI + char *kanji_table_name; + #endif /* KANJI */ mylog("%s: entering...stmt=%u\n", func, stmt); *************** *** 2077,2082 **** --- 2211,2229 ---- SC_log_error(func, "", stmt); return SQL_ERROR; } + #ifdef KANJI + { + kanji_table_name = table_name; + table_name = sjis_to_euc(kanji_table_name, SQL_NTS); + if ( ! table_name) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + free(kanji_table_name); + return SQL_ERROR; + } + } + #endif /* KANJI */ /* * we need to get a list of the field names first, so we can return *************** *** 2097,2104 **** --- 2244,2256 ---- * being shown. This would throw everything off. */ col_stmt->internal = TRUE; + #ifdef KANJI + result = SQLColumns(hcol_stmt, "", 0, "", 0, + kanji_table_name, (SWORD) strlen(kanji_table_name), "", 0); + #else /* KANJI */ result = SQLColumns(hcol_stmt, "", 0, "", 0, table_name, (SWORD) strlen(table_name), "", 0); + #endif /* KANJI */ col_stmt->internal = FALSE; if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) *************** *** 2123,2128 **** --- 2275,2298 ---- result = SQLFetch(hcol_stmt); while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(column_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hcol_stmt, SQL_DROP); + goto SEEYA; + } + strncpy_null(column_name, kanji, sizeof(column_name)); + column_name_len = strlen(column_name); + free(kanji); + } + #endif /* KANJI */ + total_columns++; column_names = *************** *** 2168,2174 **** " and d.oid = i.indrelid" " and i.indexrelid = c.oid" " and c.relam = a.oid" ! , table_name); result = SQLExecDirect(hindx_stmt, index_query, strlen(index_query)); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) --- 2338,2349 ---- " and d.oid = i.indrelid" " and i.indexrelid = c.oid" " and c.relam = a.oid" ! #ifdef KANJI ! , kanji_table_name ! #else /* KANJI */ ! , table_name ! #endif /* KANJI */ ! ); result = SQLExecDirect(hindx_stmt, index_query, strlen(index_query)); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) *************** *** 2295,2300 **** --- 2470,2494 ---- result = SQLFetch(hindx_stmt); while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(index_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(hindx_stmt, SQL_DROP); + goto SEEYA; + } + strncpy_null(index_name, kanji, sizeof(index_name)); + index_name_len = strlen(index_name); + free(kanji); + } + #endif /* KANJI */ + /* If only requesting unique indexs, then just return those. */ if (fUnique == SQL_INDEX_ALL || (fUnique == SQL_INDEX_UNIQUE && atoi(isunique))) *************** *** 2385,2390 **** --- 2579,2587 ---- SEEYA: /* These things should be freed on any error ALSO! */ free(table_name); + #ifdef KANJI + free(kanji_table_name); + #endif /* KANJI */ for (i = 0; i < total_columns; i++) free(column_names[i]); free(column_names); *************** *** 2453,2458 **** --- 2650,2658 ---- char pktab[MAX_TABLE_LEN + 1]; Int2 result_cols; int qno, qstart, qend; + #ifdef KANJI + char kanji_pktab[MAX_TABLE_LEN + 1]; + #endif /* KANJI */ mylog("%s: entering...stmt=%u\n", func, stmt); *************** *** 2513,2518 **** --- 2713,2736 ---- return SQL_ERROR; } + #ifdef KANJI + { + char *kanji; + + strcpy(kanji_pktab, pktab); + kanji = sjis_to_euc(pktab, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(pktab, kanji, sizeof(pktab)); + free(kanji); + } + #endif /* KANJI */ + result = SQLBindCol(htbl_stmt, 1, SQL_C_CHAR, attname, MAX_INFO_STRING, &attname_len); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) *************** *** 2547,2553 **** " AND ia.attrelid = i.indexrelid" " AND ta.attrelid = i.indrelid" " AND ta.attnum = i.indkey[ia.attnum-1]" ! " order by ia.attnum", pktab); break; case 2: /* --- 2765,2777 ---- " AND ia.attrelid = i.indexrelid" " AND ta.attrelid = i.indrelid" " AND ta.attnum = i.indkey[ia.attnum-1]" ! " order by ia.attnum" ! #ifdef KANJI ! , kanji_pktab ! #else /* KANJI */ ! , pktab ! #endif /* KANJI */ ! ); break; case 2: /* *************** *** 2560,2566 **** " AND ia.attrelid = i.indexrelid" " AND ta.attrelid = i.indrelid" " AND ta.attnum = i.indkey[ia.attnum-1]" ! " order by ia.attnum", pktab); break; } mylog("SQLPrimaryKeys: tables_query='%s'\n", tables_query); --- 2784,2796 ---- " AND ia.attrelid = i.indexrelid" " AND ta.attrelid = i.indrelid" " AND ta.attnum = i.indkey[ia.attnum-1]" ! " order by ia.attnum" ! #ifdef KANJI ! , kanji_pktab ! #else /* KANJI */ ! , pktab ! #endif /* KANJI */ ! ); break; } mylog("SQLPrimaryKeys: tables_query='%s'\n", tables_query); *************** *** 2582,2587 **** --- 2812,2835 ---- while ((result == SQL_SUCCESS) || (result == SQL_SUCCESS_WITH_INFO)) { + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(attname, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(attname, kanji, sizeof(attname)); + attname_len = strlen(attname); + free(kanji); + } + #endif /* KANJI */ + row = (TupleNode *) malloc(sizeof(TupleNode) + (result_cols - 1) *sizeof(TupleField)); set_tuplefield_null(&row->tuple[0]); *************** *** 2665,2670 **** --- 2913,2922 ---- del_rule[MAX_TABLE_LEN]; char pk_table_needed[MAX_TABLE_LEN + 1]; char fk_table_needed[MAX_TABLE_LEN + 1]; + #ifdef KANJI + char kanji_pk_table_needed[MAX_TABLE_LEN + 1]; + char kanji_fk_table_needed[MAX_TABLE_LEN + 1]; + #endif /* KANJI */ char *pkey_ptr, *fkey_ptr, *pk_table, *************** *** 2762,2767 **** --- 3014,3049 ---- make_string(szPkTableName, cbPkTableName, pk_table_needed); make_string(szFkTableName, cbFkTableName, fk_table_needed); + #ifdef KANJI + { + char *kanji; + + strcpy(kanji_pk_table_needed, pk_table_needed); + kanji = sjis_to_euc(pk_table_needed, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(pk_table_needed, kanji, sizeof(pk_table_needed)); + free(kanji); + + strcpy(kanji_fk_table_needed, fk_table_needed); + kanji = sjis_to_euc(fk_table_needed, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(fk_table_needed, kanji, sizeof(fk_table_needed)); + free(kanji); + } + #endif /* KANJI */ + /* * Case #2 -- Get the foreign keys in the specified table (fktab) that * refer to the primary keys of other table(s). *************** *** 2796,2802 **** "AND (pg_trigger.tgconstrname=pt.tgconstrname) " "AND (pg_trigger_1.tgrelid=pt.tgconstrrelid) " "AND (pg_trigger_1.tgconstrname=pt.tgconstrname))", ! fk_table_needed); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); --- 3078,3089 ---- "AND (pg_trigger.tgconstrname=pt.tgconstrname) " "AND (pg_trigger_1.tgrelid=pt.tgconstrrelid) " "AND (pg_trigger_1.tgconstrname=pt.tgconstrname))", ! #ifdef KANJI ! kanji_fk_table_needed ! #else /* KANJI */ ! fk_table_needed ! #endif /* KANJI */ ! ); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); *************** *** 2910,2915 **** --- 3197,3233 ---- while (result == SQL_SUCCESS) { + + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(upd_rule, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(upd_rule, kanji, sizeof(upd_rule)); + free(kanji); + + kanji = sjis_to_euc(del_rule, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(del_rule, kanji, sizeof(del_rule)); + free(kanji); + } + #endif /* KANJI */ + /* Compute the number of keyparts. */ num_keys = (trig_nargs - 4) / 2; *************** *** 2932,2938 **** --- 3250,3274 ---- } } + #ifdef KANJI + { + char *kanji; + + kanji = euc_to_sjis(pk_table, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + keyresult = SQLPrimaryKeys(hpkey_stmt, NULL, 0, NULL, 0, kanji, SQL_NTS); + free(kanji); + } + #else /* KANJI */ keyresult = SQLPrimaryKeys(hpkey_stmt, NULL, 0, NULL, 0, pk_table, SQL_NTS); + #endif /* KANJI */ if (keyresult != SQL_SUCCESS) { stmt->errornumber = STMT_NO_MEMORY_ERROR; *************** *** 2952,2957 **** --- 3288,3311 ---- for (k = 0; k < num_keys; k++) { + #ifdef KANJI + if (keyresult == SQL_SUCCESS) { + char *kanji; + + kanji = sjis_to_euc(pkey, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(pkey, kanji, sizeof(pkey)); + free(kanji); + } + #endif /* KANJI */ + mylog("%s: pkey_ptr='%s', pkey='%s'\n", func, pkey_ptr, pkey); if (keyresult != SQL_SUCCESS || strcmp(pkey_ptr, pkey)) { *************** *** 3085,3091 **** " AND (pg_trigger_1.tgrelid = pg_trigger.tgconstrrelid) " " AND (pg_trigger_2.tgrelid = pg_trigger.tgconstrrelid) " " )", ! pk_table_needed); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) --- 3439,3450 ---- " AND (pg_trigger_1.tgrelid = pg_trigger.tgconstrrelid) " " AND (pg_trigger_2.tgrelid = pg_trigger.tgconstrrelid) " " )", ! #ifdef KANJI ! kanji_pk_table_needed ! #else /* KANJI */ ! pk_table_needed ! #endif /* KANJI */ ! ); result = SQLExecDirect(htbl_stmt, tables_query, strlen(tables_query)); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) *************** *** 3178,3183 **** --- 3537,3573 ---- while (result == SQL_SUCCESS) { + + #ifdef KANJI + { + char *kanji; + + kanji = sjis_to_euc(upd_rule, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(upd_rule, kanji, sizeof(upd_rule)); + free(kanji); + + kanji = sjis_to_euc(del_rule, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + SQLFreeStmt(htbl_stmt, SQL_DROP); + SQLFreeStmt(hpkey_stmt, SQL_DROP); + return SQL_ERROR; + } + strncpy_null(del_rule, kanji, sizeof(del_rule)); + free(kanji); + } + #endif /* KANJI */ + /* Calculate the number of key parts */ num_keys = (trig_nargs - 4) / 2;; Index: psqlodbc/kanji.c diff -c /dev/null psqlodbc/kanji.c:1.1.8.1 *** /dev/null Fri Jul 13 23:18:05 2001 --- psqlodbc/kanji.c Fri Jul 13 23:05:10 2001 *************** *** 0 **** --- 1,567 ---- + /*------------------------------------------------------------------------- + * + * kanji.c - source file for kanji encoding conversion + * + * Copyright (c) 1998-2000, InterWIZ + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library (see "license.txt"); if not, write to + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA + * 02139, USA. + * + * SUPPORT WEB SITE: + * http://www.interwiz.koganei.tokyo.jp/software/PsqlODBC/ + * + *------------------------------------------------------------------------- + */ + + #include + #include + #include + #include + + #ifdef KANJI + + #include "kanji.h" + + typedef struct _MAP { + LCHAR from; + LCHAR to; + } MAP; + + #include "kanji_map.h" + + /******************************************************************* + translation(mapping) utilities + ********************************************************************/ + + /* + * character mapping translation + */ + static int translate_by_mapping(MAP *map, int map_count, LCHAR *c) + { + int lo, hi, p; /* for binary search */ + + /* bounding check */ + if (c->code < map[0].from.code || + map[map_count - 1].from.code < c->code) + return FALSE; + + /* binary search */ + lo = 0; + hi = map_count - 1; + while (p = (lo + hi) / 2, hi - lo > 0) + { + if (c->code == map[p].from.code) + break; + if (c->code < map[p].from.code) + hi = p - 1; + else + lo = p + 1; + } + if (c->code != map[p].from.code) + return FALSE; + + c->cs = map[p].to.cs; + c->code = map[p].to.code; + + return TRUE; + } + + /* + * special translation to convert from EUC to SJIS + */ + static void translate_euc_to_sjis(LCHAR *c) + { + int hi, lo; + + switch (c->cs) + { + case CS_JISX0208: + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + if (0x20 + 85 <= hi && hi <= 0x20 + 94) /* UDC1 (JISX0208 85ku-94ku) */ + { + /* move UDC1 from (JISX0208 85ku-94ku) to (UDCJP 1ku-10ku) */ + hi = hi - 85 + 1; + c->cs = CS_UDCJP; + c->code = (hi << 8) + lo; + } + break; + case CS_JISX0212: + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + if (0x20 + 85 <= hi && hi <= 0x20 + 94) /* UDC2 (JISX0212 85ku-94ku) */ + { + /* move UDC2 from (JISX0212 85ku-94ku) to (UDCJP 11ku ~ 20ku) */ + hi = hi - 85 + 11; + c->cs = CS_UDCJP; + c->code = (hi << 8) + lo; + } + else /* other JISX0212 characters */ + translate_by_mapping(map_ibm_euc_jisx0212_to_sjis, + sizeof(map_ibm_euc_jisx0212_to_sjis) / + sizeof(map_ibm_euc_jisx0212_to_sjis[0]), + c); + break; + } + } + + /* + * special translation to convert from SJIS to EUC + */ + static void translate_sjis_to_euc(LCHAR *c) + { + int hi, lo; + + switch (c->cs) + { + case CS_JISX0208: + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + if (0x20 + 89 <= hi && hi <= 0x20 + 92) /* NEC (JISX0208 89ku-92ku) */ + translate_by_mapping(map_nec_sjis_jisx0208_to_euc, + sizeof(map_nec_sjis_jisx0208_to_euc) / + sizeof(map_nec_sjis_jisx0208_to_euc[0]), + c); + else if (0x20 + 85 <= hi) /* IMPOSSIBLE AREA (JISX0208 85ku-94ku) */ + { + c->cs = CHAR_ECONVERT_WIDE_CS; + c->code = CHAR_ECONVERT_WIDE_CODE; + } + break; + case CS_UDCJP: + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + if (0x20 + 1 <= hi && hi <= 0x20 + 10) /* UDC1 (UDCJP 1ku-10ku) */ + { + /* move UDC1 from (UDCJP 1ku-10ku) to (JISX0208 85ku-94ku) */ + hi = hi - 1 + 85; + c->cs = CS_JISX0208; + c->code = (hi << 8) + lo; + } + else if (0x20 + 11 <= hi && hi <= 0x20 + 20) /* UDC2 (UDCJP 11ku-20ku) */ + { + /* move UDC2 from (UDCJP 11ku-20ku) to (JISX0212 85ku-94ku) */ + hi = hi - 11 + 85; + c->cs = CS_JISX0212; + c->code = (hi << 8) + lo; + } + else if (0x20 + 21 <= hi && hi <= 0x20 + 25) /* IBM (UDCJP 21ku-25ku) */ + translate_by_mapping(map_ibm_sjis_udcjp_to_euc, + sizeof(map_ibm_sjis_udcjp_to_euc) / + sizeof(map_ibm_sjis_udcjp_to_euc[0]), + c); + break; + } + } + + /******************************************************************* + encoding parsers + ********************************************************************/ + + /* + * decode an EUC character + */ + int decode_euc(const unsigned char *euc, int euc_len, LCHAR *c) + { + int convert_len; + int hi, lo; + + if (euc[0] <= 0x7f) + { + convert_len = 1; + if (euc_len < convert_len) + goto decode_euc_error_narrow; + c->cs = CS_ASCII; + c->code = euc[0]; + } + else if (0x80 <= euc[0] && euc[0] <= 0x9f && euc[0] != 0x8e && euc[0] != 0x8f) + { + convert_len = 1; + if (euc_len < convert_len) + goto decode_euc_error_narrow; + c->cs = CS_ISO6429; + c->code = euc[0]; + } + else if (0xa0 <= euc[0]) + { + convert_len = 2; + if (euc_len < convert_len) + goto decode_euc_error_wide; + if (euc[0] < 0xa1 || 0xfe < euc[0] || + euc[1] < 0xa1 || 0xfe < euc[1]) + goto decode_euc_error_wide; + hi = euc[0] - 0x80; + lo = euc[1] - 0x80; + c->cs = CS_JISX0208; + c->code = (hi << 8) + lo; + } + else if (euc[0] == 0x8e) + { + convert_len = 2; + if (euc_len < convert_len) + goto decode_euc_error_narrow; + c->cs = CS_JISX0201; + c->code = euc[1]; + } + else if (euc[0] == 0x8f) + { + convert_len = 3; + if (euc_len < convert_len) + goto decode_euc_error_wide; + if (euc[1] < 0xa1 || 0xfe < euc[1] || + euc[2] < 0xa1 || 0xfe < euc[2]) + goto decode_euc_error_wide; + hi = euc[1] - 0x80; + lo = euc[2] - 0x80; + c->cs = CS_JISX0212; + c->code = (hi << 8) + lo; + } + else + { + /* will not be reached */ + convert_len = 1; + goto decode_euc_error_narrow; + } + + return convert_len; + + decode_euc_error_narrow: + c->cs = CHAR_ECONVERT_NARROW_CS; + c->code = CHAR_ECONVERT_NARROW_CODE; + + return convert_len; + + decode_euc_error_wide: + c->cs = CHAR_ECONVERT_WIDE_CS; + c->code = CHAR_ECONVERT_WIDE_CODE; + + return convert_len; + } + + /* + * encode an EUC character + */ + int encode_euc(const LCHAR *c, unsigned char *euc, int euc_len) + { + int convert_len; + LCHAR econvert; + + switch (c->cs) + { + case CS_ASCII: + convert_len = 1; + if (euc_len < convert_len) + goto encode_euc_error_nospace; + euc[0] = c->code; + break; + case CS_ISO6429: + convert_len = 1; + if (euc_len < convert_len) + goto encode_euc_error_nospace; + if (c->code == 0x8e || c->code == 0x8f) + goto encode_euc_error_narrow; + euc[0] = c->code; + break; + case CS_JISX0208: + convert_len = 2; + if (euc_len < convert_len) + goto encode_euc_error_nospace; + euc[0] = ((c->code >> 8) & 0xff) + 0x80; + euc[1] = (c->code & 0xff) + 0x80; + break; + case CS_JISX0201: + convert_len = 2; + if (euc_len < convert_len) + goto encode_euc_error_nospace; + if (c->code < 0xa1 || 0xfe < c->code) + goto encode_euc_error_narrow; + euc[0] = 0x8e; + euc[1] = c->code; + break; + case CS_JISX0212: + convert_len = 3; + if (euc_len < convert_len) + goto encode_euc_error_nospace; + euc[0] = 0x8f; + euc[1] = ((c->code >> 8) & 0xff) + 0x80; + euc[2] = (c->code & 0xff) + 0x80; + break; + case CS_UDCJP: + goto encode_euc_error_wide; + default: + /* will not be reached */ + goto encode_euc_error_narrow; + } + + return convert_len; + + encode_euc_error_nospace: + return convert_len; + + encode_euc_error_narrow: + econvert.cs = CHAR_ECONVERT_NARROW_CS; + econvert.code = CHAR_ECONVERT_NARROW_CODE; + convert_len = encode_euc(&econvert, euc, euc_len); + + return convert_len; + + encode_euc_error_wide: + econvert.cs = CHAR_ECONVERT_WIDE_CS; + econvert.code = CHAR_ECONVERT_WIDE_CODE; + convert_len = encode_euc(&econvert, euc, euc_len); + + return convert_len; + } + + /* + * decode an SJIS character + */ + int decode_sjis(const unsigned char *sjis, int sjis_len, LCHAR *c) + { + int convert_len; + int hi, lo; + + if (sjis[0] <= 0x7f) + { + convert_len = 1; + if (sjis_len < convert_len) + goto decode_sjis_error_narrow; + c->cs = CS_ASCII; + c->code = sjis[0]; + } + else if ((0x81 <= sjis[0] && sjis[0] <= 0x9f) || + (0xe0 <= sjis[0] && sjis[0] <= 0xef)) + { + convert_len = 2; + if (sjis_len < convert_len) + goto decode_sjis_error_wide; + if (sjis[1] < 0x40 || 0xfc < sjis[1] || sjis[1] == 0x7f) + goto decode_sjis_error_wide; + hi = sjis[0]; + lo = sjis[1]; + hi = hi + (hi < 0xe0 ? - 0x81 : - 0xc1); + lo = lo + (lo < 0x80 ? - 0x40 : - 0x41); + hi = hi * 2 + (lo < 0x5e ? 0x00 : 0x01); + lo = lo + (lo < 0x5e ? 0x00 : - 0x5e); + hi = hi + 0x21; + lo = lo + 0x21; + c->cs = CS_JISX0208; + c->code = (hi << 8) + lo; + } + else if ((0xf0 <= sjis[0] && sjis[0] <= 0xfc)) + { + convert_len = 2; + if (sjis_len < convert_len) + goto decode_sjis_error_wide; + if (sjis[1] < 0x40 || 0xfc < sjis[1] || sjis[1] == 0x7f) + goto decode_sjis_error_wide; + hi = sjis[0]; + lo = sjis[1]; + hi = hi - 0xf0; + lo = lo + (lo < 0x80 ? - 0x40 : - 0x41); + hi = hi * 2 + (lo < 0x5e ? 0x00 : 0x01); + lo = lo + (lo < 0x5e ? 0x00 : - 0x5e); + hi = hi + 0x21; + lo = lo + 0x21; + c->cs = CS_UDCJP; + c->code = (hi << 8) + lo; + } + else if (0xa1 <= sjis[0] && sjis[0] <= 0xdf) + { + convert_len = 1; + if (sjis_len < convert_len) + goto decode_sjis_error_narrow; + c->cs = CS_JISX0201; + c->code = sjis[0]; + } + else + { + /* will not be reached */ + convert_len = 1; + goto decode_sjis_error_narrow; + } + + return convert_len; + + decode_sjis_error_narrow: + c->cs = CHAR_ECONVERT_NARROW_CS; + c->code = CHAR_ECONVERT_NARROW_CODE; + + return convert_len; + + decode_sjis_error_wide: + c->cs = CHAR_ECONVERT_WIDE_CS; + c->code = CHAR_ECONVERT_WIDE_CODE; + + return convert_len; + } + + /* + * encode an SJIS character + */ + int encode_sjis(const LCHAR *c, unsigned char *sjis, int sjis_len) + { + int convert_len; + int hi, lo; + LCHAR econvert; + + switch (c->cs) + { + case CS_ASCII: + convert_len = 1; + if (sjis_len < convert_len) + goto encode_sjis_error_nospace; + sjis[0] = c->code; + break; + case CS_ISO6429: + goto encode_sjis_error_narrow; + case CS_JISX0208: + convert_len = 2; + if (sjis_len < convert_len) + goto encode_sjis_error_nospace; + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + hi = hi - 0x21; + lo = lo - 0x21; + lo = lo + (hi % 2 == 0 ? 0x00 : 0x5e); + hi = hi / 2; + hi = hi + (hi < 0x1f ? 0x81 : 0xc1); + lo = lo + (lo < 0x3f ? 0x40 : 0x41); + sjis[0] = hi; + sjis[1] = lo; + break; + case CS_JISX0201: + convert_len = 1; + if (sjis_len < convert_len) + goto encode_sjis_error_nospace; + sjis[0] = c->code; + break; + case CS_JISX0212: + goto encode_sjis_error_wide; + case CS_UDCJP: + convert_len = 2; + if (sjis_len < convert_len) + goto encode_sjis_error_nospace; + hi = (c->code >> 8) & 0xff; + lo = c->code & 0xff; + hi = hi - 0x21; + lo = lo - 0x21; + lo = lo + (hi % 2 == 0 ? 0x00 : 0x5e); + hi = hi / 2; + hi = hi + 0xf0; + lo = lo + (lo < 0x3f ? 0x40 : 0x41); + sjis[0] = hi; + sjis[1] = lo; + break; + default: + /* will not be reached */ + goto encode_sjis_error_narrow; + } + + return convert_len; + + encode_sjis_error_nospace: + return convert_len; + + encode_sjis_error_narrow: + econvert.cs = CHAR_ECONVERT_NARROW_CS; + econvert.code = CHAR_ECONVERT_NARROW_CODE; + convert_len = encode_sjis(&econvert, sjis, sjis_len); + + return convert_len; + + encode_sjis_error_wide: + econvert.cs = CHAR_ECONVERT_WIDE_CS; + econvert.code = CHAR_ECONVERT_WIDE_CODE; + convert_len = encode_sjis(&econvert, sjis, sjis_len); + + return convert_len; + } + + /******************************************************************* + encoding converters + ********************************************************************/ + + /* + * convert a kanji string from EUC to SJIS + * + * return value is a converted buffer + */ + char *euc_to_sjis(const char *euc, int euc_len) + { + char *sjis; + int sjis_len; + int s; /* source pointer */ + int d; /* destination pointer */ + LCHAR c; /* logical character data */ + int l; /* offset length */ + + if (euc_len == SQL_NTS) + euc_len = strlen(euc); + sjis_len = euc_len; + sjis = (char *)malloc(sjis_len + 1); + if (!sjis) return NULL; + + s = 0; + d = 0; + while (s < euc_len) { + s += decode_euc(euc + s, euc_len - s, &c); + translate_euc_to_sjis(&c); + l = encode_sjis(&c, sjis + d, sjis_len - d); + if (l > sjis_len - d) + break; + d += l; + } + sjis[d] = 0; + + return sjis; + } + + /* + * convert a kanji string from SJIS to EUC + * + * return value is a converted buffer + */ + char *sjis_to_euc(const char *sjis, int sjis_len) + { + char *euc; + int euc_len; + int s; /* source pointer */ + int d; /* destination pointer */ + LCHAR c; /* logical character data */ + int l; /* offset length */ + + if (sjis_len == SQL_NTS) + sjis_len = strlen(sjis); + euc_len = sjis_len * 2; + euc = (char *)malloc(euc_len + 1); + if (!euc) return NULL; + + s = 0; + d = 0; + while (s < sjis_len) { + s += decode_sjis(sjis + s, sjis_len - s, &c); + translate_sjis_to_euc(&c); + l = encode_euc(&c, euc + d, euc_len - d); + if (l > euc_len - d) + break; + d += l; + } + euc[d] = 0; + + return euc; + } + + #endif /* KANJI */ Index: psqlodbc/kanji.h diff -c /dev/null psqlodbc/kanji.h:1.1.8.1 *** /dev/null Fri Jul 13 23:18:05 2001 --- psqlodbc/kanji.h Fri Jul 13 23:05:10 2001 *************** *** 0 **** --- 1,57 ---- + /*------------------------------------------------------------------------- + * + * kanji.h - header file for kanji encoding conversion + * + * Copyright (c) 1998-2000, InterWIZ + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library (see "license.txt"); if not, write to + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA + * 02139, USA. + * + * SUPPORT WEB SITE: + * http://www.interwiz.koganei.tokyo.jp/software/PsqlODBC/ + * + *------------------------------------------------------------------------- + */ + + /* logical character */ + typedef struct _LCHAR { + int cs; /* character set */ + int code; /* character code */ + } LCHAR; + + /* character sets */ + #define CS_ASCII 0 + #define CS_ISO6429 1 + #define CS_JISX0201 2 + #define CS_JISX0208 3 + #define CS_JISX0212 4 + #define CS_UDCJP 5 + + /* an indicatable characters to show the impossible encoding + conversion as the narrow character */ + #define CHAR_ECONVERT_NARROW_CS CS_ASCII; + #define CHAR_ECONVERT_NARROW_CODE 0x3f; + + /* an indicatable characters to show the impossible encoding + conversion as the wide character */ + #define CHAR_ECONVERT_WIDE_CS CS_JISX0208; + #define CHAR_ECONVERT_WIDE_CODE 0x222e; + + int decode_euc(const unsigned char *euc, int euc_len, LCHAR *c); + int encode_euc(const LCHAR *c, unsigned char *euc, int euc_len); + int decode_sjis(const unsigned char *sjis, int sjis_len, LCHAR *c); + int encode_sjis(const LCHAR *c, unsigned char *sjis, int sjis_len); + char *sjis_to_euc(const char *sjis, int sjis_len); + char *euc_to_sjis(const char *euc, int euc_len); Index: psqlodbc/kanji_map.h diff -c /dev/null psqlodbc/kanji_map.h:1.1.8.1 *** /dev/null Fri Jul 13 23:18:05 2001 --- psqlodbc/kanji_map.h Fri Jul 13 23:05:12 2001 *************** *** 0 **** --- 1,1196 ---- + /*------------------------------------------------------------------------- + * + * kanji_map.h - header file for kanji translation tables + * + * Copyright (c) 1998-2000, InterWIZ + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library (see "license.txt"); if not, write to + * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA + * 02139, USA. + * + * SUPPORT WEB SITE: + * http://www.interwiz.koganei.tokyo.jp/software/PsqlODBC/ + * + *------------------------------------------------------------------------- + */ + + /* + * IBM extended kanji translation tables + */ + + static MAP map_ibm_euc_jisx0208_to_sjis[] = { + {{CS_JISX0208, 0x224c}, {CS_UDCJP , 0x3535}}, + {{CS_JISX0208, 0x2268}, {CS_UDCJP , 0x353c}}, + }; + + static MAP map_ibm_euc_jisx0212_to_sjis[] = { + {{CS_JISX0212, 0x2243}, {CS_UDCJP , 0x3536}}, + {{CS_JISX0212, 0x3029}, {CS_UDCJP , 0x3549}}, + {{CS_JISX0212, 0x3048}, {CS_UDCJP , 0x354a}}, + {{CS_JISX0212, 0x3052}, {CS_UDCJP , 0x354c}}, + {{CS_JISX0212, 0x3054}, {CS_UDCJP , 0x354d}}, + {{CS_JISX0212, 0x3063}, {CS_UDCJP , 0x354e}}, + {{CS_JISX0212, 0x306e}, {CS_UDCJP , 0x354f}}, + {{CS_JISX0212, 0x3123}, {CS_UDCJP , 0x3551}}, + {{CS_JISX0212, 0x3127}, {CS_UDCJP , 0x3550}}, + {{CS_JISX0212, 0x3129}, {CS_UDCJP , 0x3553}}, + {{CS_JISX0212, 0x312c}, {CS_UDCJP , 0x3552}}, + {{CS_JISX0212, 0x313b}, {CS_UDCJP , 0x3542}}, + {{CS_JISX0212, 0x313e}, {CS_UDCJP , 0x3554}}, + {{CS_JISX0212, 0x3148}, {CS_UDCJP , 0x3557}}, + {{CS_JISX0212, 0x3157}, {CS_UDCJP , 0x3558}}, + {{CS_JISX0212, 0x3158}, {CS_UDCJP , 0x3556}}, + {{CS_JISX0212, 0x315f}, {CS_UDCJP , 0x3555}}, + {{CS_JISX0212, 0x3161}, {CS_UDCJP , 0x355b}}, + {{CS_JISX0212, 0x3163}, {CS_UDCJP , 0x3559}}, + {{CS_JISX0212, 0x3174}, {CS_UDCJP , 0x355a}}, + {{CS_JISX0212, 0x3223}, {CS_UDCJP , 0x355c}}, + {{CS_JISX0212, 0x323b}, {CS_UDCJP , 0x355e}}, + {{CS_JISX0212, 0x3266}, {CS_UDCJP , 0x355f}}, + {{CS_JISX0212, 0x326d}, {CS_UDCJP , 0x3560}}, + {{CS_JISX0212, 0x3275}, {CS_UDCJP , 0x3561}}, + {{CS_JISX0212, 0x327c}, {CS_UDCJP , 0x3562}}, + {{CS_JISX0212, 0x3335}, {CS_UDCJP , 0x3564}}, + {{CS_JISX0212, 0x3358}, {CS_UDCJP , 0x3565}}, + {{CS_JISX0212, 0x335b}, {CS_UDCJP , 0x3566}}, + {{CS_JISX0212, 0x335d}, {CS_UDCJP , 0x3758}}, + {{CS_JISX0212, 0x3365}, {CS_UDCJP , 0x3567}}, + {{CS_JISX0212, 0x336e}, {CS_UDCJP , 0x3568}}, + {{CS_JISX0212, 0x337b}, {CS_UDCJP , 0x3569}}, + {{CS_JISX0212, 0x3440}, {CS_UDCJP , 0x356c}}, + {{CS_JISX0212, 0x3447}, {CS_UDCJP , 0x356d}}, + {{CS_JISX0212, 0x3450}, {CS_UDCJP , 0x356e}}, + {{CS_JISX0212, 0x345e}, {CS_UDCJP , 0x356f}}, + {{CS_JISX0212, 0x352a}, {CS_UDCJP , 0x3571}}, + {{CS_JISX0212, 0x352f}, {CS_UDCJP , 0x3573}}, + {{CS_JISX0212, 0x3544}, {CS_UDCJP , 0x3574}}, + {{CS_JISX0212, 0x3568}, {CS_UDCJP , 0x3575}}, + {{CS_JISX0212, 0x3742}, {CS_UDCJP , 0x3577}}, + {{CS_JISX0212, 0x3764}, {CS_UDCJP , 0x3578}}, + {{CS_JISX0212, 0x3767}, {CS_UDCJP , 0x357a}}, + {{CS_JISX0212, 0x3768}, {CS_UDCJP , 0x3579}}, + {{CS_JISX0212, 0x384e}, {CS_UDCJP , 0x357e}}, + {{CS_JISX0212, 0x3861}, {CS_UDCJP , 0x3621}}, + {{CS_JISX0212, 0x3875}, {CS_UDCJP , 0x3622}}, + {{CS_JISX0212, 0x3877}, {CS_UDCJP , 0x3623}}, + {{CS_JISX0212, 0x3878}, {CS_UDCJP , 0x3624}}, + {{CS_JISX0212, 0x387c}, {CS_UDCJP , 0x3625}}, + {{CS_JISX0212, 0x392f}, {CS_UDCJP , 0x3626}}, + {{CS_JISX0212, 0x3937}, {CS_UDCJP , 0x3627}}, + {{CS_JISX0212, 0x3a3e}, {CS_UDCJP , 0x3628}}, + {{CS_JISX0212, 0x3a5b}, {CS_UDCJP , 0x3629}}, + {{CS_JISX0212, 0x3a61}, {CS_UDCJP , 0x362b}}, + {{CS_JISX0212, 0x3a6b}, {CS_UDCJP , 0x362d}}, + {{CS_JISX0212, 0x3b33}, {CS_UDCJP , 0x362e}}, + {{CS_JISX0212, 0x3b38}, {CS_UDCJP , 0x362f}}, + {{CS_JISX0212, 0x3b4a}, {CS_UDCJP , 0x3631}}, + {{CS_JISX0212, 0x3b50}, {CS_UDCJP , 0x3634}}, + {{CS_JISX0212, 0x3b5e}, {CS_UDCJP , 0x3635}}, + {{CS_JISX0212, 0x3b74}, {CS_UDCJP , 0x3636}}, + {{CS_JISX0212, 0x3b75}, {CS_UDCJP , 0x3637}}, + {{CS_JISX0212, 0x3b79}, {CS_UDCJP , 0x3638}}, + {{CS_JISX0212, 0x3c64}, {CS_UDCJP , 0x3639}}, + {{CS_JISX0212, 0x3c6d}, {CS_UDCJP , 0x363a}}, + {{CS_JISX0212, 0x3c74}, {CS_UDCJP , 0x3548}}, + {{CS_JISX0212, 0x3c7e}, {CS_UDCJP , 0x363b}}, + {{CS_JISX0212, 0x3d42}, {CS_UDCJP , 0x363d}}, + {{CS_JISX0212, 0x3d67}, {CS_UDCJP , 0x363e}}, + {{CS_JISX0212, 0x3d70}, {CS_UDCJP , 0x3640}}, + {{CS_JISX0212, 0x3e2c}, {CS_UDCJP , 0x3642}}, + {{CS_JISX0212, 0x3e30}, {CS_UDCJP , 0x3641}}, + {{CS_JISX0212, 0x3e33}, {CS_UDCJP , 0x3644}}, + {{CS_JISX0212, 0x3e3d}, {CS_UDCJP , 0x3645}}, + {{CS_JISX0212, 0x3e49}, {CS_UDCJP , 0x3647}}, + {{CS_JISX0212, 0x3e4d}, {CS_UDCJP , 0x3646}}, + {{CS_JISX0212, 0x3e64}, {CS_UDCJP , 0x3648}}, + {{CS_JISX0212, 0x3f28}, {CS_UDCJP , 0x3649}}, + {{CS_JISX0212, 0x3f49}, {CS_UDCJP , 0x364a}}, + {{CS_JISX0212, 0x4044}, {CS_UDCJP , 0x364b}}, + {{CS_JISX0212, 0x4064}, {CS_UDCJP , 0x364c}}, + {{CS_JISX0212, 0x4074}, {CS_UDCJP , 0x364d}}, + {{CS_JISX0212, 0x4126}, {CS_UDCJP , 0x364e}}, + {{CS_JISX0212, 0x4175}, {CS_UDCJP , 0x3650}}, + {{CS_JISX0212, 0x4178}, {CS_UDCJP , 0x3653}}, + {{CS_JISX0212, 0x417c}, {CS_UDCJP , 0x3651}}, + {{CS_JISX0212, 0x4221}, {CS_UDCJP , 0x3655}}, + {{CS_JISX0212, 0x4225}, {CS_UDCJP , 0x3656}}, + {{CS_JISX0212, 0x422b}, {CS_UDCJP , 0x3654}}, + {{CS_JISX0212, 0x422d}, {CS_UDCJP , 0x3544}}, + {{CS_JISX0212, 0x4238}, {CS_UDCJP , 0x3658}}, + {{CS_JISX0212, 0x423a}, {CS_UDCJP , 0x3659}}, + {{CS_JISX0212, 0x423f}, {CS_UDCJP , 0x3547}}, + {{CS_JISX0212, 0x4244}, {CS_UDCJP , 0x365b}}, + {{CS_JISX0212, 0x4252}, {CS_UDCJP , 0x365c}}, + {{CS_JISX0212, 0x4257}, {CS_UDCJP , 0x365d}}, + {{CS_JISX0212, 0x425b}, {CS_UDCJP , 0x365e}}, + {{CS_JISX0212, 0x425e}, {CS_UDCJP , 0x365f}}, + {{CS_JISX0212, 0x426d}, {CS_UDCJP , 0x3660}}, + {{CS_JISX0212, 0x4270}, {CS_UDCJP , 0x3661}}, + {{CS_JISX0212, 0x4321}, {CS_UDCJP , 0x3663}}, + {{CS_JISX0212, 0x4335}, {CS_UDCJP , 0x3664}}, + {{CS_JISX0212, 0x4339}, {CS_UDCJP , 0x3666}}, + {{CS_JISX0212, 0x4349}, {CS_UDCJP , 0x3665}}, + {{CS_JISX0212, 0x4358}, {CS_UDCJP , 0x3668}}, + {{CS_JISX0212, 0x437c}, {CS_UDCJP , 0x3545}}, + {{CS_JISX0212, 0x437e}, {CS_UDCJP , 0x3669}}, + {{CS_JISX0212, 0x444c}, {CS_UDCJP , 0x366b}}, + {{CS_JISX0212, 0x4459}, {CS_UDCJP , 0x366d}}, + {{CS_JISX0212, 0x446a}, {CS_UDCJP , 0x366e}}, + {{CS_JISX0212, 0x447d}, {CS_UDCJP , 0x366f}}, + {{CS_JISX0212, 0x4527}, {CS_UDCJP , 0x3671}}, + {{CS_JISX0212, 0x4535}, {CS_UDCJP , 0x3672}}, + {{CS_JISX0212, 0x4536}, {CS_UDCJP , 0x3673}}, + {{CS_JISX0212, 0x4555}, {CS_UDCJP , 0x3675}}, + {{CS_JISX0212, 0x4638}, {CS_UDCJP , 0x3676}}, + {{CS_JISX0212, 0x4657}, {CS_UDCJP , 0x3677}}, + {{CS_JISX0212, 0x4660}, {CS_UDCJP , 0x3678}}, + {{CS_JISX0212, 0x4663}, {CS_UDCJP , 0x367a}}, + {{CS_JISX0212, 0x466a}, {CS_UDCJP , 0x3679}}, + {{CS_JISX0212, 0x4721}, {CS_UDCJP , 0x367b}}, + {{CS_JISX0212, 0x472b}, {CS_UDCJP , 0x367c}}, + {{CS_JISX0212, 0x4743}, {CS_UDCJP , 0x367e}}, + {{CS_JISX0212, 0x4747}, {CS_UDCJP , 0x367d}}, + {{CS_JISX0212, 0x474b}, {CS_UDCJP , 0x3721}}, + {{CS_JISX0212, 0x474f}, {CS_UDCJP , 0x3722}}, + {{CS_JISX0212, 0x4759}, {CS_UDCJP , 0x3723}}, + {{CS_JISX0212, 0x4766}, {CS_UDCJP , 0x3726}}, + {{CS_JISX0212, 0x476b}, {CS_UDCJP , 0x3729}}, + {{CS_JISX0212, 0x476e}, {CS_UDCJP , 0x3727}}, + {{CS_JISX0212, 0x4770}, {CS_UDCJP , 0x372a}}, + {{CS_JISX0212, 0x477c}, {CS_UDCJP , 0x3728}}, + {{CS_JISX0212, 0x4831}, {CS_UDCJP , 0x372b}}, + {{CS_JISX0212, 0x4865}, {CS_UDCJP , 0x372c}}, + {{CS_JISX0212, 0x4878}, {CS_UDCJP , 0x372d}}, + {{CS_JISX0212, 0x4926}, {CS_UDCJP , 0x372e}}, + {{CS_JISX0212, 0x492b}, {CS_UDCJP , 0x372f}}, + {{CS_JISX0212, 0x492d}, {CS_UDCJP , 0x3730}}, + {{CS_JISX0212, 0x494a}, {CS_UDCJP , 0x3732}}, + {{CS_JISX0212, 0x4953}, {CS_UDCJP , 0x3733}}, + {{CS_JISX0212, 0x4963}, {CS_UDCJP , 0x3735}}, + {{CS_JISX0212, 0x4969}, {CS_UDCJP , 0x3734}}, + {{CS_JISX0212, 0x4974}, {CS_UDCJP , 0x3737}}, + {{CS_JISX0212, 0x4975}, {CS_UDCJP , 0x3738}}, + {{CS_JISX0212, 0x497c}, {CS_UDCJP , 0x3736}}, + {{CS_JISX0212, 0x4a33}, {CS_UDCJP , 0x373a}}, + {{CS_JISX0212, 0x4a3d}, {CS_UDCJP , 0x373b}}, + {{CS_JISX0212, 0x4a6f}, {CS_UDCJP , 0x373c}}, + {{CS_JISX0212, 0x4a71}, {CS_UDCJP , 0x373d}}, + {{CS_JISX0212, 0x4b2e}, {CS_UDCJP , 0x373e}}, + {{CS_JISX0212, 0x4b4a}, {CS_UDCJP , 0x3740}}, + {{CS_JISX0212, 0x4b66}, {CS_UDCJP , 0x3741}}, + {{CS_JISX0212, 0x4b6a}, {CS_UDCJP , 0x3742}}, + {{CS_JISX0212, 0x4b6e}, {CS_UDCJP , 0x3745}}, + {{CS_JISX0212, 0x4b70}, {CS_UDCJP , 0x3743}}, + {{CS_JISX0212, 0x4b74}, {CS_UDCJP , 0x3744}}, + {{CS_JISX0212, 0x4b79}, {CS_UDCJP , 0x3747}}, + {{CS_JISX0212, 0x4c25}, {CS_UDCJP , 0x3746}}, + {{CS_JISX0212, 0x4c2b}, {CS_UDCJP , 0x3748}}, + {{CS_JISX0212, 0x4c2d}, {CS_UDCJP , 0x374a}}, + {{CS_JISX0212, 0x4c2e}, {CS_UDCJP , 0x3749}}, + {{CS_JISX0212, 0x4c32}, {CS_UDCJP , 0x374b}}, + {{CS_JISX0212, 0x4c42}, {CS_UDCJP , 0x374c}}, + {{CS_JISX0212, 0x4c50}, {CS_UDCJP , 0x374d}}, + {{CS_JISX0212, 0x4c59}, {CS_UDCJP , 0x374e}}, + {{CS_JISX0212, 0x4d2a}, {CS_UDCJP , 0x362a}}, + {{CS_JISX0212, 0x4d3b}, {CS_UDCJP , 0x3750}}, + {{CS_JISX0212, 0x4e3a}, {CS_UDCJP , 0x3754}}, + {{CS_JISX0212, 0x4e3b}, {CS_UDCJP , 0x3752}}, + {{CS_JISX0212, 0x4e43}, {CS_UDCJP , 0x3755}}, + {{CS_JISX0212, 0x4e72}, {CS_UDCJP , 0x3757}}, + {{CS_JISX0212, 0x4f55}, {CS_UDCJP , 0x3759}}, + {{CS_JISX0212, 0x4f62}, {CS_UDCJP , 0x375a}}, + {{CS_JISX0212, 0x4f69}, {CS_UDCJP , 0x375b}}, + {{CS_JISX0212, 0x4f6d}, {CS_UDCJP , 0x375c}}, + {{CS_JISX0212, 0x5065}, {CS_UDCJP , 0x3761}}, + {{CS_JISX0212, 0x5069}, {CS_UDCJP , 0x3763}}, + {{CS_JISX0212, 0x5168}, {CS_UDCJP , 0x3764}}, + {{CS_JISX0212, 0x516c}, {CS_UDCJP , 0x3767}}, + {{CS_JISX0212, 0x523b}, {CS_UDCJP , 0x3768}}, + {{CS_JISX0212, 0x5361}, {CS_UDCJP , 0x376a}}, + {{CS_JISX0212, 0x5368}, {CS_UDCJP , 0x376b}}, + {{CS_JISX0212, 0x5427}, {CS_UDCJP , 0x376c}}, + {{CS_JISX0212, 0x5454}, {CS_UDCJP , 0x376f}}, + {{CS_JISX0212, 0x5463}, {CS_UDCJP , 0x353d}}, + {{CS_JISX0212, 0x5472}, {CS_UDCJP , 0x3770}}, + {{CS_JISX0212, 0x552e}, {CS_UDCJP , 0x3771}}, + {{CS_JISX0212, 0x575e}, {CS_UDCJP , 0x3773}}, + {{CS_JISX0212, 0x5822}, {CS_UDCJP , 0x3775}}, + {{CS_JISX0212, 0x5837}, {CS_UDCJP , 0x3776}}, + {{CS_JISX0212, 0x5841}, {CS_UDCJP , 0x3777}}, + {{CS_JISX0212, 0x5851}, {CS_UDCJP , 0x3778}}, + {{CS_JISX0212, 0x5874}, {CS_UDCJP , 0x3779}}, + {{CS_JISX0212, 0x5921}, {CS_UDCJP , 0x3541}}, + {{CS_JISX0212, 0x5946}, {CS_UDCJP , 0x377a}}, + {{CS_JISX0212, 0x5948}, {CS_UDCJP , 0x377b}}, + {{CS_JISX0212, 0x5951}, {CS_UDCJP , 0x377c}}, + {{CS_JISX0212, 0x5c53}, {CS_UDCJP , 0x3824}}, + {{CS_JISX0212, 0x5c5f}, {CS_UDCJP , 0x353e}}, + {{CS_JISX0212, 0x5d48}, {CS_UDCJP , 0x3825}}, + {{CS_JISX0212, 0x5d54}, {CS_UDCJP , 0x3826}}, + {{CS_JISX0212, 0x5d6a}, {CS_UDCJP , 0x3827}}, + {{CS_JISX0212, 0x5d7a}, {CS_UDCJP , 0x3828}}, + {{CS_JISX0212, 0x5e24}, {CS_UDCJP , 0x3829}}, + {{CS_JISX0212, 0x5e30}, {CS_UDCJP , 0x382a}}, + {{CS_JISX0212, 0x5e35}, {CS_UDCJP , 0x382c}}, + {{CS_JISX0212, 0x5e4b}, {CS_UDCJP , 0x382d}}, + {{CS_JISX0212, 0x5f39}, {CS_UDCJP , 0x382f}}, + {{CS_JISX0212, 0x5f43}, {CS_UDCJP , 0x3831}}, + {{CS_JISX0212, 0x6059}, {CS_UDCJP , 0x3834}}, + {{CS_JISX0212, 0x6162}, {CS_UDCJP , 0x3837}}, + {{CS_JISX0212, 0x6247}, {CS_UDCJP , 0x383b}}, + {{CS_JISX0212, 0x6326}, {CS_UDCJP , 0x383d}}, + {{CS_JISX0212, 0x6328}, {CS_UDCJP , 0x383c}}, + {{CS_JISX0212, 0x6329}, {CS_UDCJP , 0x383e}}, + {{CS_JISX0212, 0x632a}, {CS_UDCJP , 0x3841}}, + {{CS_JISX0212, 0x632b}, {CS_UDCJP , 0x3842}}, + {{CS_JISX0212, 0x632f}, {CS_UDCJP , 0x383f}}, + {{CS_JISX0212, 0x6330}, {CS_UDCJP , 0x3840}}, + {{CS_JISX0212, 0x633c}, {CS_UDCJP , 0x3843}}, + {{CS_JISX0212, 0x633f}, {CS_UDCJP , 0x3845}}, + {{CS_JISX0212, 0x6341}, {CS_UDCJP , 0x3844}}, + {{CS_JISX0212, 0x6354}, {CS_UDCJP , 0x384c}}, + {{CS_JISX0212, 0x6355}, {CS_UDCJP , 0x3846}}, + {{CS_JISX0212, 0x6356}, {CS_UDCJP , 0x3848}}, + {{CS_JISX0212, 0x6358}, {CS_UDCJP , 0x3847}}, + {{CS_JISX0212, 0x635f}, {CS_UDCJP , 0x3849}}, + {{CS_JISX0212, 0x6361}, {CS_UDCJP , 0x384b}}, + {{CS_JISX0212, 0x6363}, {CS_UDCJP , 0x384a}}, + {{CS_JISX0212, 0x6369}, {CS_UDCJP , 0x384d}}, + {{CS_JISX0212, 0x6371}, {CS_UDCJP , 0x384f}}, + {{CS_JISX0212, 0x6372}, {CS_UDCJP , 0x3850}}, + {{CS_JISX0212, 0x6378}, {CS_UDCJP , 0x3540}}, + {{CS_JISX0212, 0x6426}, {CS_UDCJP , 0x384e}}, + {{CS_JISX0212, 0x643e}, {CS_UDCJP , 0x3854}}, + {{CS_JISX0212, 0x643f}, {CS_UDCJP , 0x3858}}, + {{CS_JISX0212, 0x6440}, {CS_UDCJP , 0x3856}}, + {{CS_JISX0212, 0x6441}, {CS_UDCJP , 0x3852}}, + {{CS_JISX0212, 0x6443}, {CS_UDCJP , 0x3853}}, + {{CS_JISX0212, 0x6447}, {CS_UDCJP , 0x3857}}, + {{CS_JISX0212, 0x644b}, {CS_UDCJP , 0x3851}}, + {{CS_JISX0212, 0x6450}, {CS_UDCJP , 0x3546}}, + {{CS_JISX0212, 0x6451}, {CS_UDCJP , 0x385b}}, + {{CS_JISX0212, 0x6452}, {CS_UDCJP , 0x385e}}, + {{CS_JISX0212, 0x6454}, {CS_UDCJP , 0x3860}}, + {{CS_JISX0212, 0x645b}, {CS_UDCJP , 0x385f}}, + {{CS_JISX0212, 0x645c}, {CS_UDCJP , 0x385d}}, + {{CS_JISX0212, 0x645e}, {CS_UDCJP , 0x385a}}, + {{CS_JISX0212, 0x6460}, {CS_UDCJP , 0x3859}}, + {{CS_JISX0212, 0x6469}, {CS_UDCJP , 0x353f}}, + {{CS_JISX0212, 0x646f}, {CS_UDCJP , 0x3862}}, + {{CS_JISX0212, 0x647a}, {CS_UDCJP , 0x3861}}, + {{CS_JISX0212, 0x6533}, {CS_UDCJP , 0x3863}}, + {{CS_JISX0212, 0x653f}, {CS_UDCJP , 0x3864}}, + {{CS_JISX0212, 0x6549}, {CS_UDCJP , 0x3865}}, + {{CS_JISX0212, 0x6550}, {CS_UDCJP , 0x3866}}, + {{CS_JISX0212, 0x6562}, {CS_UDCJP , 0x3867}}, + {{CS_JISX0212, 0x656a}, {CS_UDCJP , 0x3868}}, + {{CS_JISX0212, 0x656b}, {CS_UDCJP , 0x3869}}, + {{CS_JISX0212, 0x6668}, {CS_UDCJP , 0x386d}}, + {{CS_JISX0212, 0x666f}, {CS_UDCJP , 0x386e}}, + {{CS_JISX0212, 0x672c}, {CS_UDCJP , 0x386f}}, + {{CS_JISX0212, 0x672e}, {CS_UDCJP , 0x3871}}, + {{CS_JISX0212, 0x6731}, {CS_UDCJP , 0x3873}}, + {{CS_JISX0212, 0x6732}, {CS_UDCJP , 0x3875}}, + {{CS_JISX0212, 0x6831}, {CS_UDCJP , 0x3876}}, + {{CS_JISX0212, 0x6836}, {CS_UDCJP , 0x3877}}, + {{CS_JISX0212, 0x685d}, {CS_UDCJP , 0x387a}}, + {{CS_JISX0212, 0x6951}, {CS_UDCJP , 0x387d}}, + {{CS_JISX0212, 0x696d}, {CS_UDCJP , 0x3921}}, + {{CS_JISX0212, 0x6a4d}, {CS_UDCJP , 0x3922}}, + {{CS_JISX0212, 0x6a5b}, {CS_UDCJP , 0x3924}}, + {{CS_JISX0212, 0x6a66}, {CS_UDCJP , 0x3925}}, + {{CS_JISX0212, 0x6a6a}, {CS_UDCJP , 0x3926}}, + {{CS_JISX0212, 0x6b25}, {CS_UDCJP , 0x3927}}, + {{CS_JISX0212, 0x6b7a}, {CS_UDCJP , 0x3929}}, + {{CS_JISX0212, 0x6b7b}, {CS_UDCJP , 0x3928}}, + {{CS_JISX0212, 0x6c56}, {CS_UDCJP , 0x392b}}, + {{CS_JISX0212, 0x7373}, {CS_UDCJP , 0x3521}}, + {{CS_JISX0212, 0x7374}, {CS_UDCJP , 0x3522}}, + {{CS_JISX0212, 0x7375}, {CS_UDCJP , 0x3523}}, + {{CS_JISX0212, 0x7376}, {CS_UDCJP , 0x3524}}, + {{CS_JISX0212, 0x7377}, {CS_UDCJP , 0x3525}}, + {{CS_JISX0212, 0x7378}, {CS_UDCJP , 0x3526}}, + {{CS_JISX0212, 0x7379}, {CS_UDCJP , 0x3527}}, + {{CS_JISX0212, 0x737a}, {CS_UDCJP , 0x3528}}, + {{CS_JISX0212, 0x737b}, {CS_UDCJP , 0x3529}}, + {{CS_JISX0212, 0x737c}, {CS_UDCJP , 0x352a}}, + {{CS_JISX0212, 0x737d}, {CS_UDCJP , 0x352b}}, + {{CS_JISX0212, 0x737e}, {CS_UDCJP , 0x352c}}, + {{CS_JISX0212, 0x7421}, {CS_UDCJP , 0x352d}}, + {{CS_JISX0212, 0x7422}, {CS_UDCJP , 0x352e}}, + {{CS_JISX0212, 0x7423}, {CS_UDCJP , 0x352f}}, + {{CS_JISX0212, 0x7424}, {CS_UDCJP , 0x3530}}, + {{CS_JISX0212, 0x7425}, {CS_UDCJP , 0x3531}}, + {{CS_JISX0212, 0x7426}, {CS_UDCJP , 0x3532}}, + {{CS_JISX0212, 0x7427}, {CS_UDCJP , 0x3533}}, + {{CS_JISX0212, 0x7428}, {CS_UDCJP , 0x3534}}, + {{CS_JISX0212, 0x7429}, {CS_UDCJP , 0x3537}}, + {{CS_JISX0212, 0x742a}, {CS_UDCJP , 0x3538}}, + {{CS_JISX0212, 0x742b}, {CS_UDCJP , 0x3539}}, + {{CS_JISX0212, 0x742c}, {CS_UDCJP , 0x353a}}, + {{CS_JISX0212, 0x742d}, {CS_UDCJP , 0x353b}}, + {{CS_JISX0212, 0x742e}, {CS_UDCJP , 0x3543}}, + {{CS_JISX0212, 0x742f}, {CS_UDCJP , 0x354b}}, + {{CS_JISX0212, 0x7430}, {CS_UDCJP , 0x355d}}, + {{CS_JISX0212, 0x7431}, {CS_UDCJP , 0x3563}}, + {{CS_JISX0212, 0x7432}, {CS_UDCJP , 0x356a}}, + {{CS_JISX0212, 0x7433}, {CS_UDCJP , 0x356b}}, + {{CS_JISX0212, 0x7434}, {CS_UDCJP , 0x3570}}, + {{CS_JISX0212, 0x7435}, {CS_UDCJP , 0x3572}}, + {{CS_JISX0212, 0x7436}, {CS_UDCJP , 0x3576}}, + {{CS_JISX0212, 0x7437}, {CS_UDCJP , 0x357b}}, + {{CS_JISX0212, 0x7438}, {CS_UDCJP , 0x357c}}, + {{CS_JISX0212, 0x7439}, {CS_UDCJP , 0x357d}}, + {{CS_JISX0212, 0x743a}, {CS_UDCJP , 0x362c}}, + {{CS_JISX0212, 0x743b}, {CS_UDCJP , 0x3630}}, + {{CS_JISX0212, 0x743c}, {CS_UDCJP , 0x3632}}, + {{CS_JISX0212, 0x743d}, {CS_UDCJP , 0x3633}}, + {{CS_JISX0212, 0x743e}, {CS_UDCJP , 0x363c}}, + {{CS_JISX0212, 0x743f}, {CS_UDCJP , 0x363f}}, + {{CS_JISX0212, 0x7440}, {CS_UDCJP , 0x3643}}, + {{CS_JISX0212, 0x7441}, {CS_UDCJP , 0x364f}}, + {{CS_JISX0212, 0x7442}, {CS_UDCJP , 0x3652}}, + {{CS_JISX0212, 0x7443}, {CS_UDCJP , 0x3657}}, + {{CS_JISX0212, 0x7444}, {CS_UDCJP , 0x365a}}, + {{CS_JISX0212, 0x7445}, {CS_UDCJP , 0x3662}}, + {{CS_JISX0212, 0x7446}, {CS_UDCJP , 0x3667}}, + {{CS_JISX0212, 0x7447}, {CS_UDCJP , 0x366a}}, + {{CS_JISX0212, 0x7448}, {CS_UDCJP , 0x366c}}, + {{CS_JISX0212, 0x7449}, {CS_UDCJP , 0x3670}}, + {{CS_JISX0212, 0x744a}, {CS_UDCJP , 0x3674}}, + {{CS_JISX0212, 0x744b}, {CS_UDCJP , 0x3724}}, + {{CS_JISX0212, 0x744c}, {CS_UDCJP , 0x3725}}, + {{CS_JISX0212, 0x744d}, {CS_UDCJP , 0x3731}}, + {{CS_JISX0212, 0x744e}, {CS_UDCJP , 0x3739}}, + {{CS_JISX0212, 0x744f}, {CS_UDCJP , 0x373f}}, + {{CS_JISX0212, 0x7450}, {CS_UDCJP , 0x374f}}, + {{CS_JISX0212, 0x7451}, {CS_UDCJP , 0x3751}}, + {{CS_JISX0212, 0x7452}, {CS_UDCJP , 0x3753}}, + {{CS_JISX0212, 0x7453}, {CS_UDCJP , 0x3756}}, + {{CS_JISX0212, 0x7454}, {CS_UDCJP , 0x375d}}, + {{CS_JISX0212, 0x7455}, {CS_UDCJP , 0x375e}}, + {{CS_JISX0212, 0x7456}, {CS_UDCJP , 0x375f}}, + {{CS_JISX0212, 0x7457}, {CS_UDCJP , 0x3760}}, + {{CS_JISX0212, 0x7458}, {CS_UDCJP , 0x3762}}, + {{CS_JISX0212, 0x7459}, {CS_UDCJP , 0x3765}}, + {{CS_JISX0212, 0x745a}, {CS_UDCJP , 0x3766}}, + {{CS_JISX0212, 0x745b}, {CS_UDCJP , 0x3769}}, + {{CS_JISX0212, 0x745c}, {CS_UDCJP , 0x376d}}, + {{CS_JISX0212, 0x745d}, {CS_UDCJP , 0x376e}}, + {{CS_JISX0212, 0x745e}, {CS_UDCJP , 0x3772}}, + {{CS_JISX0212, 0x745f}, {CS_UDCJP , 0x3774}}, + {{CS_JISX0212, 0x7460}, {CS_UDCJP , 0x377d}}, + {{CS_JISX0212, 0x7461}, {CS_UDCJP , 0x377e}}, + {{CS_JISX0212, 0x7462}, {CS_UDCJP , 0x3821}}, + {{CS_JISX0212, 0x7463}, {CS_UDCJP , 0x3822}}, + {{CS_JISX0212, 0x7464}, {CS_UDCJP , 0x3823}}, + {{CS_JISX0212, 0x7465}, {CS_UDCJP , 0x382b}}, + {{CS_JISX0212, 0x7466}, {CS_UDCJP , 0x382e}}, + {{CS_JISX0212, 0x7467}, {CS_UDCJP , 0x3830}}, + {{CS_JISX0212, 0x7468}, {CS_UDCJP , 0x3832}}, + {{CS_JISX0212, 0x7469}, {CS_UDCJP , 0x3833}}, + {{CS_JISX0212, 0x746a}, {CS_UDCJP , 0x3835}}, + {{CS_JISX0212, 0x746b}, {CS_UDCJP , 0x3836}}, + {{CS_JISX0212, 0x746c}, {CS_UDCJP , 0x3838}}, + {{CS_JISX0212, 0x746d}, {CS_UDCJP , 0x3839}}, + {{CS_JISX0212, 0x746e}, {CS_UDCJP , 0x383a}}, + {{CS_JISX0212, 0x746f}, {CS_UDCJP , 0x3855}}, + {{CS_JISX0212, 0x7470}, {CS_UDCJP , 0x385c}}, + {{CS_JISX0212, 0x7471}, {CS_UDCJP , 0x386a}}, + {{CS_JISX0212, 0x7472}, {CS_UDCJP , 0x386b}}, + {{CS_JISX0212, 0x7473}, {CS_UDCJP , 0x386c}}, + {{CS_JISX0212, 0x7474}, {CS_UDCJP , 0x3870}}, + {{CS_JISX0212, 0x7475}, {CS_UDCJP , 0x3872}}, + {{CS_JISX0212, 0x7476}, {CS_UDCJP , 0x3874}}, + {{CS_JISX0212, 0x7477}, {CS_UDCJP , 0x3878}}, + {{CS_JISX0212, 0x7478}, {CS_UDCJP , 0x3879}}, + {{CS_JISX0212, 0x7479}, {CS_UDCJP , 0x387b}}, + {{CS_JISX0212, 0x747a}, {CS_UDCJP , 0x387c}}, + {{CS_JISX0212, 0x747b}, {CS_UDCJP , 0x387e}}, + {{CS_JISX0212, 0x747c}, {CS_UDCJP , 0x3923}}, + {{CS_JISX0212, 0x747d}, {CS_UDCJP , 0x392a}}, + {{CS_JISX0212, 0x747e}, {CS_UDCJP , 0x392c}}, + }; + + static MAP map_ibm_sjis_udcjp_to_euc[] = { + {{CS_UDCJP , 0x3521}, {CS_JISX0212, 0x7373}}, + {{CS_UDCJP , 0x3522}, {CS_JISX0212, 0x7374}}, + {{CS_UDCJP , 0x3523}, {CS_JISX0212, 0x7375}}, + {{CS_UDCJP , 0x3524}, {CS_JISX0212, 0x7376}}, + {{CS_UDCJP , 0x3525}, {CS_JISX0212, 0x7377}}, + {{CS_UDCJP , 0x3526}, {CS_JISX0212, 0x7378}}, + {{CS_UDCJP , 0x3527}, {CS_JISX0212, 0x7379}}, + {{CS_UDCJP , 0x3528}, {CS_JISX0212, 0x737a}}, + {{CS_UDCJP , 0x3529}, {CS_JISX0212, 0x737b}}, + {{CS_UDCJP , 0x352a}, {CS_JISX0212, 0x737c}}, + {{CS_UDCJP , 0x352b}, {CS_JISX0212, 0x737d}}, + {{CS_UDCJP , 0x352c}, {CS_JISX0212, 0x737e}}, + {{CS_UDCJP , 0x352d}, {CS_JISX0212, 0x7421}}, + {{CS_UDCJP , 0x352e}, {CS_JISX0212, 0x7422}}, + {{CS_UDCJP , 0x352f}, {CS_JISX0212, 0x7423}}, + {{CS_UDCJP , 0x3530}, {CS_JISX0212, 0x7424}}, + {{CS_UDCJP , 0x3531}, {CS_JISX0212, 0x7425}}, + {{CS_UDCJP , 0x3532}, {CS_JISX0212, 0x7426}}, + {{CS_UDCJP , 0x3533}, {CS_JISX0212, 0x7427}}, + {{CS_UDCJP , 0x3534}, {CS_JISX0212, 0x7428}}, + {{CS_UDCJP , 0x3535}, {CS_JISX0208, 0x224c}}, + {{CS_UDCJP , 0x3536}, {CS_JISX0212, 0x2243}}, + {{CS_UDCJP , 0x3537}, {CS_JISX0212, 0x7429}}, + {{CS_UDCJP , 0x3538}, {CS_JISX0212, 0x742a}}, + {{CS_UDCJP , 0x3539}, {CS_JISX0212, 0x742b}}, + {{CS_UDCJP , 0x353a}, {CS_JISX0212, 0x742c}}, + {{CS_UDCJP , 0x353b}, {CS_JISX0212, 0x742d}}, + {{CS_UDCJP , 0x353c}, {CS_JISX0208, 0x2268}}, + {{CS_UDCJP , 0x353d}, {CS_JISX0212, 0x5463}}, + {{CS_UDCJP , 0x353e}, {CS_JISX0212, 0x5c5f}}, + {{CS_UDCJP , 0x353f}, {CS_JISX0212, 0x6469}}, + {{CS_UDCJP , 0x3540}, {CS_JISX0212, 0x6378}}, + {{CS_UDCJP , 0x3541}, {CS_JISX0212, 0x5921}}, + {{CS_UDCJP , 0x3542}, {CS_JISX0212, 0x313b}}, + {{CS_UDCJP , 0x3543}, {CS_JISX0212, 0x742e}}, + {{CS_UDCJP , 0x3544}, {CS_JISX0212, 0x422d}}, + {{CS_UDCJP , 0x3545}, {CS_JISX0212, 0x437c}}, + {{CS_UDCJP , 0x3546}, {CS_JISX0212, 0x6450}}, + {{CS_UDCJP , 0x3547}, {CS_JISX0212, 0x423f}}, + {{CS_UDCJP , 0x3548}, {CS_JISX0212, 0x3c74}}, + {{CS_UDCJP , 0x3549}, {CS_JISX0212, 0x3029}}, + {{CS_UDCJP , 0x354a}, {CS_JISX0212, 0x3048}}, + {{CS_UDCJP , 0x354b}, {CS_JISX0212, 0x742f}}, + {{CS_UDCJP , 0x354c}, {CS_JISX0212, 0x3052}}, + {{CS_UDCJP , 0x354d}, {CS_JISX0212, 0x3054}}, + {{CS_UDCJP , 0x354e}, {CS_JISX0212, 0x3063}}, + {{CS_UDCJP , 0x354f}, {CS_JISX0212, 0x306e}}, + {{CS_UDCJP , 0x3550}, {CS_JISX0212, 0x3127}}, + {{CS_UDCJP , 0x3551}, {CS_JISX0212, 0x3123}}, + {{CS_UDCJP , 0x3552}, {CS_JISX0212, 0x312c}}, + {{CS_UDCJP , 0x3553}, {CS_JISX0212, 0x3129}}, + {{CS_UDCJP , 0x3554}, {CS_JISX0212, 0x313e}}, + {{CS_UDCJP , 0x3555}, {CS_JISX0212, 0x315f}}, + {{CS_UDCJP , 0x3556}, {CS_JISX0212, 0x3158}}, + {{CS_UDCJP , 0x3557}, {CS_JISX0212, 0x3148}}, + {{CS_UDCJP , 0x3558}, {CS_JISX0212, 0x3157}}, + {{CS_UDCJP , 0x3559}, {CS_JISX0212, 0x3163}}, + {{CS_UDCJP , 0x355a}, {CS_JISX0212, 0x3174}}, + {{CS_UDCJP , 0x355b}, {CS_JISX0212, 0x3161}}, + {{CS_UDCJP , 0x355c}, {CS_JISX0212, 0x3223}}, + {{CS_UDCJP , 0x355d}, {CS_JISX0212, 0x7430}}, + {{CS_UDCJP , 0x355e}, {CS_JISX0212, 0x323b}}, + {{CS_UDCJP , 0x355f}, {CS_JISX0212, 0x3266}}, + {{CS_UDCJP , 0x3560}, {CS_JISX0212, 0x326d}}, + {{CS_UDCJP , 0x3561}, {CS_JISX0212, 0x3275}}, + {{CS_UDCJP , 0x3562}, {CS_JISX0212, 0x327c}}, + {{CS_UDCJP , 0x3563}, {CS_JISX0212, 0x7431}}, + {{CS_UDCJP , 0x3564}, {CS_JISX0212, 0x3335}}, + {{CS_UDCJP , 0x3565}, {CS_JISX0212, 0x3358}}, + {{CS_UDCJP , 0x3566}, {CS_JISX0212, 0x335b}}, + {{CS_UDCJP , 0x3567}, {CS_JISX0212, 0x3365}}, + {{CS_UDCJP , 0x3568}, {CS_JISX0212, 0x336e}}, + {{CS_UDCJP , 0x3569}, {CS_JISX0212, 0x337b}}, + {{CS_UDCJP , 0x356a}, {CS_JISX0212, 0x7432}}, + {{CS_UDCJP , 0x356b}, {CS_JISX0212, 0x7433}}, + {{CS_UDCJP , 0x356c}, {CS_JISX0212, 0x3440}}, + {{CS_UDCJP , 0x356d}, {CS_JISX0212, 0x3447}}, + {{CS_UDCJP , 0x356e}, {CS_JISX0212, 0x3450}}, + {{CS_UDCJP , 0x356f}, {CS_JISX0212, 0x345e}}, + {{CS_UDCJP , 0x3570}, {CS_JISX0212, 0x7434}}, + {{CS_UDCJP , 0x3571}, {CS_JISX0212, 0x352a}}, + {{CS_UDCJP , 0x3572}, {CS_JISX0212, 0x7435}}, + {{CS_UDCJP , 0x3573}, {CS_JISX0212, 0x352f}}, + {{CS_UDCJP , 0x3574}, {CS_JISX0212, 0x3544}}, + {{CS_UDCJP , 0x3575}, {CS_JISX0212, 0x3568}}, + {{CS_UDCJP , 0x3576}, {CS_JISX0212, 0x7436}}, + {{CS_UDCJP , 0x3577}, {CS_JISX0212, 0x3742}}, + {{CS_UDCJP , 0x3578}, {CS_JISX0212, 0x3764}}, + {{CS_UDCJP , 0x3579}, {CS_JISX0212, 0x3768}}, + {{CS_UDCJP , 0x357a}, {CS_JISX0212, 0x3767}}, + {{CS_UDCJP , 0x357b}, {CS_JISX0212, 0x7437}}, + {{CS_UDCJP , 0x357c}, {CS_JISX0212, 0x7438}}, + {{CS_UDCJP , 0x357d}, {CS_JISX0212, 0x7439}}, + {{CS_UDCJP , 0x357e}, {CS_JISX0212, 0x384e}}, + {{CS_UDCJP , 0x3621}, {CS_JISX0212, 0x3861}}, + {{CS_UDCJP , 0x3622}, {CS_JISX0212, 0x3875}}, + {{CS_UDCJP , 0x3623}, {CS_JISX0212, 0x3877}}, + {{CS_UDCJP , 0x3624}, {CS_JISX0212, 0x3878}}, + {{CS_UDCJP , 0x3625}, {CS_JISX0212, 0x387c}}, + {{CS_UDCJP , 0x3626}, {CS_JISX0212, 0x392f}}, + {{CS_UDCJP , 0x3627}, {CS_JISX0212, 0x3937}}, + {{CS_UDCJP , 0x3628}, {CS_JISX0212, 0x3a3e}}, + {{CS_UDCJP , 0x3629}, {CS_JISX0212, 0x3a5b}}, + {{CS_UDCJP , 0x362a}, {CS_JISX0212, 0x4d2a}}, + {{CS_UDCJP , 0x362b}, {CS_JISX0212, 0x3a61}}, + {{CS_UDCJP , 0x362c}, {CS_JISX0212, 0x743a}}, + {{CS_UDCJP , 0x362d}, {CS_JISX0212, 0x3a6b}}, + {{CS_UDCJP , 0x362e}, {CS_JISX0212, 0x3b33}}, + {{CS_UDCJP , 0x362f}, {CS_JISX0212, 0x3b38}}, + {{CS_UDCJP , 0x3630}, {CS_JISX0212, 0x743b}}, + {{CS_UDCJP , 0x3631}, {CS_JISX0212, 0x3b4a}}, + {{CS_UDCJP , 0x3632}, {CS_JISX0212, 0x743c}}, + {{CS_UDCJP , 0x3633}, {CS_JISX0212, 0x743d}}, + {{CS_UDCJP , 0x3634}, {CS_JISX0212, 0x3b50}}, + {{CS_UDCJP , 0x3635}, {CS_JISX0212, 0x3b5e}}, + {{CS_UDCJP , 0x3636}, {CS_JISX0212, 0x3b74}}, + {{CS_UDCJP , 0x3637}, {CS_JISX0212, 0x3b75}}, + {{CS_UDCJP , 0x3638}, {CS_JISX0212, 0x3b79}}, + {{CS_UDCJP , 0x3639}, {CS_JISX0212, 0x3c64}}, + {{CS_UDCJP , 0x363a}, {CS_JISX0212, 0x3c6d}}, + {{CS_UDCJP , 0x363b}, {CS_JISX0212, 0x3c7e}}, + {{CS_UDCJP , 0x363c}, {CS_JISX0212, 0x743e}}, + {{CS_UDCJP , 0x363d}, {CS_JISX0212, 0x3d42}}, + {{CS_UDCJP , 0x363e}, {CS_JISX0212, 0x3d67}}, + {{CS_UDCJP , 0x363f}, {CS_JISX0212, 0x743f}}, + {{CS_UDCJP , 0x3640}, {CS_JISX0212, 0x3d70}}, + {{CS_UDCJP , 0x3641}, {CS_JISX0212, 0x3e30}}, + {{CS_UDCJP , 0x3642}, {CS_JISX0212, 0x3e2c}}, + {{CS_UDCJP , 0x3643}, {CS_JISX0212, 0x7440}}, + {{CS_UDCJP , 0x3644}, {CS_JISX0212, 0x3e33}}, + {{CS_UDCJP , 0x3645}, {CS_JISX0212, 0x3e3d}}, + {{CS_UDCJP , 0x3646}, {CS_JISX0212, 0x3e4d}}, + {{CS_UDCJP , 0x3647}, {CS_JISX0212, 0x3e49}}, + {{CS_UDCJP , 0x3648}, {CS_JISX0212, 0x3e64}}, + {{CS_UDCJP , 0x3649}, {CS_JISX0212, 0x3f28}}, + {{CS_UDCJP , 0x364a}, {CS_JISX0212, 0x3f49}}, + {{CS_UDCJP , 0x364b}, {CS_JISX0212, 0x4044}}, + {{CS_UDCJP , 0x364c}, {CS_JISX0212, 0x4064}}, + {{CS_UDCJP , 0x364d}, {CS_JISX0212, 0x4074}}, + {{CS_UDCJP , 0x364e}, {CS_JISX0212, 0x4126}}, + {{CS_UDCJP , 0x364f}, {CS_JISX0212, 0x7441}}, + {{CS_UDCJP , 0x3650}, {CS_JISX0212, 0x4175}}, + {{CS_UDCJP , 0x3651}, {CS_JISX0212, 0x417c}}, + {{CS_UDCJP , 0x3652}, {CS_JISX0212, 0x7442}}, + {{CS_UDCJP , 0x3653}, {CS_JISX0212, 0x4178}}, + {{CS_UDCJP , 0x3654}, {CS_JISX0212, 0x422b}}, + {{CS_UDCJP , 0x3655}, {CS_JISX0212, 0x4221}}, + {{CS_UDCJP , 0x3656}, {CS_JISX0212, 0x4225}}, + {{CS_UDCJP , 0x3657}, {CS_JISX0212, 0x7443}}, + {{CS_UDCJP , 0x3658}, {CS_JISX0212, 0x4238}}, + {{CS_UDCJP , 0x3659}, {CS_JISX0212, 0x423a}}, + {{CS_UDCJP , 0x365a}, {CS_JISX0212, 0x7444}}, + {{CS_UDCJP , 0x365b}, {CS_JISX0212, 0x4244}}, + {{CS_UDCJP , 0x365c}, {CS_JISX0212, 0x4252}}, + {{CS_UDCJP , 0x365d}, {CS_JISX0212, 0x4257}}, + {{CS_UDCJP , 0x365e}, {CS_JISX0212, 0x425b}}, + {{CS_UDCJP , 0x365f}, {CS_JISX0212, 0x425e}}, + {{CS_UDCJP , 0x3660}, {CS_JISX0212, 0x426d}}, + {{CS_UDCJP , 0x3661}, {CS_JISX0212, 0x4270}}, + {{CS_UDCJP , 0x3662}, {CS_JISX0212, 0x7445}}, + {{CS_UDCJP , 0x3663}, {CS_JISX0212, 0x4321}}, + {{CS_UDCJP , 0x3664}, {CS_JISX0212, 0x4335}}, + {{CS_UDCJP , 0x3665}, {CS_JISX0212, 0x4349}}, + {{CS_UDCJP , 0x3666}, {CS_JISX0212, 0x4339}}, + {{CS_UDCJP , 0x3667}, {CS_JISX0212, 0x7446}}, + {{CS_UDCJP , 0x3668}, {CS_JISX0212, 0x4358}}, + {{CS_UDCJP , 0x3669}, {CS_JISX0212, 0x437e}}, + {{CS_UDCJP , 0x366a}, {CS_JISX0212, 0x7447}}, + {{CS_UDCJP , 0x366b}, {CS_JISX0212, 0x444c}}, + {{CS_UDCJP , 0x366c}, {CS_JISX0212, 0x7448}}, + {{CS_UDCJP , 0x366d}, {CS_JISX0212, 0x4459}}, + {{CS_UDCJP , 0x366e}, {CS_JISX0212, 0x446a}}, + {{CS_UDCJP , 0x366f}, {CS_JISX0212, 0x447d}}, + {{CS_UDCJP , 0x3670}, {CS_JISX0212, 0x7449}}, + {{CS_UDCJP , 0x3671}, {CS_JISX0212, 0x4527}}, + {{CS_UDCJP , 0x3672}, {CS_JISX0212, 0x4535}}, + {{CS_UDCJP , 0x3673}, {CS_JISX0212, 0x4536}}, + {{CS_UDCJP , 0x3674}, {CS_JISX0212, 0x744a}}, + {{CS_UDCJP , 0x3675}, {CS_JISX0212, 0x4555}}, + {{CS_UDCJP , 0x3676}, {CS_JISX0212, 0x4638}}, + {{CS_UDCJP , 0x3677}, {CS_JISX0212, 0x4657}}, + {{CS_UDCJP , 0x3678}, {CS_JISX0212, 0x4660}}, + {{CS_UDCJP , 0x3679}, {CS_JISX0212, 0x466a}}, + {{CS_UDCJP , 0x367a}, {CS_JISX0212, 0x4663}}, + {{CS_UDCJP , 0x367b}, {CS_JISX0212, 0x4721}}, + {{CS_UDCJP , 0x367c}, {CS_JISX0212, 0x472b}}, + {{CS_UDCJP , 0x367d}, {CS_JISX0212, 0x4747}}, + {{CS_UDCJP , 0x367e}, {CS_JISX0212, 0x4743}}, + {{CS_UDCJP , 0x3721}, {CS_JISX0212, 0x474b}}, + {{CS_UDCJP , 0x3722}, {CS_JISX0212, 0x474f}}, + {{CS_UDCJP , 0x3723}, {CS_JISX0212, 0x4759}}, + {{CS_UDCJP , 0x3724}, {CS_JISX0212, 0x744b}}, + {{CS_UDCJP , 0x3725}, {CS_JISX0212, 0x744c}}, + {{CS_UDCJP , 0x3726}, {CS_JISX0212, 0x4766}}, + {{CS_UDCJP , 0x3727}, {CS_JISX0212, 0x476e}}, + {{CS_UDCJP , 0x3728}, {CS_JISX0212, 0x477c}}, + {{CS_UDCJP , 0x3729}, {CS_JISX0212, 0x476b}}, + {{CS_UDCJP , 0x372a}, {CS_JISX0212, 0x4770}}, + {{CS_UDCJP , 0x372b}, {CS_JISX0212, 0x4831}}, + {{CS_UDCJP , 0x372c}, {CS_JISX0212, 0x4865}}, + {{CS_UDCJP , 0x372d}, {CS_JISX0212, 0x4878}}, + {{CS_UDCJP , 0x372e}, {CS_JISX0212, 0x4926}}, + {{CS_UDCJP , 0x372f}, {CS_JISX0212, 0x492b}}, + {{CS_UDCJP , 0x3730}, {CS_JISX0212, 0x492d}}, + {{CS_UDCJP , 0x3731}, {CS_JISX0212, 0x744d}}, + {{CS_UDCJP , 0x3732}, {CS_JISX0212, 0x494a}}, + {{CS_UDCJP , 0x3733}, {CS_JISX0212, 0x4953}}, + {{CS_UDCJP , 0x3734}, {CS_JISX0212, 0x4969}}, + {{CS_UDCJP , 0x3735}, {CS_JISX0212, 0x4963}}, + {{CS_UDCJP , 0x3736}, {CS_JISX0212, 0x497c}}, + {{CS_UDCJP , 0x3737}, {CS_JISX0212, 0x4974}}, + {{CS_UDCJP , 0x3738}, {CS_JISX0212, 0x4975}}, + {{CS_UDCJP , 0x3739}, {CS_JISX0212, 0x744e}}, + {{CS_UDCJP , 0x373a}, {CS_JISX0212, 0x4a33}}, + {{CS_UDCJP , 0x373b}, {CS_JISX0212, 0x4a3d}}, + {{CS_UDCJP , 0x373c}, {CS_JISX0212, 0x4a6f}}, + {{CS_UDCJP , 0x373d}, {CS_JISX0212, 0x4a71}}, + {{CS_UDCJP , 0x373e}, {CS_JISX0212, 0x4b2e}}, + {{CS_UDCJP , 0x373f}, {CS_JISX0212, 0x744f}}, + {{CS_UDCJP , 0x3740}, {CS_JISX0212, 0x4b4a}}, + {{CS_UDCJP , 0x3741}, {CS_JISX0212, 0x4b66}}, + {{CS_UDCJP , 0x3742}, {CS_JISX0212, 0x4b6a}}, + {{CS_UDCJP , 0x3743}, {CS_JISX0212, 0x4b70}}, + {{CS_UDCJP , 0x3744}, {CS_JISX0212, 0x4b74}}, + {{CS_UDCJP , 0x3745}, {CS_JISX0212, 0x4b6e}}, + {{CS_UDCJP , 0x3746}, {CS_JISX0212, 0x4c25}}, + {{CS_UDCJP , 0x3747}, {CS_JISX0212, 0x4b79}}, + {{CS_UDCJP , 0x3748}, {CS_JISX0212, 0x4c2b}}, + {{CS_UDCJP , 0x3749}, {CS_JISX0212, 0x4c2e}}, + {{CS_UDCJP , 0x374a}, {CS_JISX0212, 0x4c2d}}, + {{CS_UDCJP , 0x374b}, {CS_JISX0212, 0x4c32}}, + {{CS_UDCJP , 0x374c}, {CS_JISX0212, 0x4c42}}, + {{CS_UDCJP , 0x374d}, {CS_JISX0212, 0x4c50}}, + {{CS_UDCJP , 0x374e}, {CS_JISX0212, 0x4c59}}, + {{CS_UDCJP , 0x374f}, {CS_JISX0212, 0x7450}}, + {{CS_UDCJP , 0x3750}, {CS_JISX0212, 0x4d3b}}, + {{CS_UDCJP , 0x3751}, {CS_JISX0212, 0x7451}}, + {{CS_UDCJP , 0x3752}, {CS_JISX0212, 0x4e3b}}, + {{CS_UDCJP , 0x3753}, {CS_JISX0212, 0x7452}}, + {{CS_UDCJP , 0x3754}, {CS_JISX0212, 0x4e3a}}, + {{CS_UDCJP , 0x3755}, {CS_JISX0212, 0x4e43}}, + {{CS_UDCJP , 0x3756}, {CS_JISX0212, 0x7453}}, + {{CS_UDCJP , 0x3757}, {CS_JISX0212, 0x4e72}}, + {{CS_UDCJP , 0x3758}, {CS_JISX0212, 0x335d}}, + {{CS_UDCJP , 0x3759}, {CS_JISX0212, 0x4f55}}, + {{CS_UDCJP , 0x375a}, {CS_JISX0212, 0x4f62}}, + {{CS_UDCJP , 0x375b}, {CS_JISX0212, 0x4f69}}, + {{CS_UDCJP , 0x375c}, {CS_JISX0212, 0x4f6d}}, + {{CS_UDCJP , 0x375d}, {CS_JISX0212, 0x7454}}, + {{CS_UDCJP , 0x375e}, {CS_JISX0212, 0x7455}}, + {{CS_UDCJP , 0x375f}, {CS_JISX0212, 0x7456}}, + {{CS_UDCJP , 0x3760}, {CS_JISX0212, 0x7457}}, + {{CS_UDCJP , 0x3761}, {CS_JISX0212, 0x5065}}, + {{CS_UDCJP , 0x3762}, {CS_JISX0212, 0x7458}}, + {{CS_UDCJP , 0x3763}, {CS_JISX0212, 0x5069}}, + {{CS_UDCJP , 0x3764}, {CS_JISX0212, 0x5168}}, + {{CS_UDCJP , 0x3765}, {CS_JISX0212, 0x7459}}, + {{CS_UDCJP , 0x3766}, {CS_JISX0212, 0x745a}}, + {{CS_UDCJP , 0x3767}, {CS_JISX0212, 0x516c}}, + {{CS_UDCJP , 0x3768}, {CS_JISX0212, 0x523b}}, + {{CS_UDCJP , 0x3769}, {CS_JISX0212, 0x745b}}, + {{CS_UDCJP , 0x376a}, {CS_JISX0212, 0x5361}}, + {{CS_UDCJP , 0x376b}, {CS_JISX0212, 0x5368}}, + {{CS_UDCJP , 0x376c}, {CS_JISX0212, 0x5427}}, + {{CS_UDCJP , 0x376d}, {CS_JISX0212, 0x745c}}, + {{CS_UDCJP , 0x376e}, {CS_JISX0212, 0x745d}}, + {{CS_UDCJP , 0x376f}, {CS_JISX0212, 0x5454}}, + {{CS_UDCJP , 0x3770}, {CS_JISX0212, 0x5472}}, + {{CS_UDCJP , 0x3771}, {CS_JISX0212, 0x552e}}, + {{CS_UDCJP , 0x3772}, {CS_JISX0212, 0x745e}}, + {{CS_UDCJP , 0x3773}, {CS_JISX0212, 0x575e}}, + {{CS_UDCJP , 0x3774}, {CS_JISX0212, 0x745f}}, + {{CS_UDCJP , 0x3775}, {CS_JISX0212, 0x5822}}, + {{CS_UDCJP , 0x3776}, {CS_JISX0212, 0x5837}}, + {{CS_UDCJP , 0x3777}, {CS_JISX0212, 0x5841}}, + {{CS_UDCJP , 0x3778}, {CS_JISX0212, 0x5851}}, + {{CS_UDCJP , 0x3779}, {CS_JISX0212, 0x5874}}, + {{CS_UDCJP , 0x377a}, {CS_JISX0212, 0x5946}}, + {{CS_UDCJP , 0x377b}, {CS_JISX0212, 0x5948}}, + {{CS_UDCJP , 0x377c}, {CS_JISX0212, 0x5951}}, + {{CS_UDCJP , 0x377d}, {CS_JISX0212, 0x7460}}, + {{CS_UDCJP , 0x377e}, {CS_JISX0212, 0x7461}}, + {{CS_UDCJP , 0x3821}, {CS_JISX0212, 0x7462}}, + {{CS_UDCJP , 0x3822}, {CS_JISX0212, 0x7463}}, + {{CS_UDCJP , 0x3823}, {CS_JISX0212, 0x7464}}, + {{CS_UDCJP , 0x3824}, {CS_JISX0212, 0x5c53}}, + {{CS_UDCJP , 0x3825}, {CS_JISX0212, 0x5d48}}, + {{CS_UDCJP , 0x3826}, {CS_JISX0212, 0x5d54}}, + {{CS_UDCJP , 0x3827}, {CS_JISX0212, 0x5d6a}}, + {{CS_UDCJP , 0x3828}, {CS_JISX0212, 0x5d7a}}, + {{CS_UDCJP , 0x3829}, {CS_JISX0212, 0x5e24}}, + {{CS_UDCJP , 0x382a}, {CS_JISX0212, 0x5e30}}, + {{CS_UDCJP , 0x382b}, {CS_JISX0212, 0x7465}}, + {{CS_UDCJP , 0x382c}, {CS_JISX0212, 0x5e35}}, + {{CS_UDCJP , 0x382d}, {CS_JISX0212, 0x5e4b}}, + {{CS_UDCJP , 0x382e}, {CS_JISX0212, 0x7466}}, + {{CS_UDCJP , 0x382f}, {CS_JISX0212, 0x5f39}}, + {{CS_UDCJP , 0x3830}, {CS_JISX0212, 0x7467}}, + {{CS_UDCJP , 0x3831}, {CS_JISX0212, 0x5f43}}, + {{CS_UDCJP , 0x3832}, {CS_JISX0212, 0x7468}}, + {{CS_UDCJP , 0x3833}, {CS_JISX0212, 0x7469}}, + {{CS_UDCJP , 0x3834}, {CS_JISX0212, 0x6059}}, + {{CS_UDCJP , 0x3835}, {CS_JISX0212, 0x746a}}, + {{CS_UDCJP , 0x3836}, {CS_JISX0212, 0x746b}}, + {{CS_UDCJP , 0x3837}, {CS_JISX0212, 0x6162}}, + {{CS_UDCJP , 0x3838}, {CS_JISX0212, 0x746c}}, + {{CS_UDCJP , 0x3839}, {CS_JISX0212, 0x746d}}, + {{CS_UDCJP , 0x383a}, {CS_JISX0212, 0x746e}}, + {{CS_UDCJP , 0x383b}, {CS_JISX0212, 0x6247}}, + {{CS_UDCJP , 0x383c}, {CS_JISX0212, 0x6328}}, + {{CS_UDCJP , 0x383d}, {CS_JISX0212, 0x6326}}, + {{CS_UDCJP , 0x383e}, {CS_JISX0212, 0x6329}}, + {{CS_UDCJP , 0x383f}, {CS_JISX0212, 0x632f}}, + {{CS_UDCJP , 0x3840}, {CS_JISX0212, 0x6330}}, + {{CS_UDCJP , 0x3841}, {CS_JISX0212, 0x632a}}, + {{CS_UDCJP , 0x3842}, {CS_JISX0212, 0x632b}}, + {{CS_UDCJP , 0x3843}, {CS_JISX0212, 0x633c}}, + {{CS_UDCJP , 0x3844}, {CS_JISX0212, 0x6341}}, + {{CS_UDCJP , 0x3845}, {CS_JISX0212, 0x633f}}, + {{CS_UDCJP , 0x3846}, {CS_JISX0212, 0x6355}}, + {{CS_UDCJP , 0x3847}, {CS_JISX0212, 0x6358}}, + {{CS_UDCJP , 0x3848}, {CS_JISX0212, 0x6356}}, + {{CS_UDCJP , 0x3849}, {CS_JISX0212, 0x635f}}, + {{CS_UDCJP , 0x384a}, {CS_JISX0212, 0x6363}}, + {{CS_UDCJP , 0x384b}, {CS_JISX0212, 0x6361}}, + {{CS_UDCJP , 0x384c}, {CS_JISX0212, 0x6354}}, + {{CS_UDCJP , 0x384d}, {CS_JISX0212, 0x6369}}, + {{CS_UDCJP , 0x384e}, {CS_JISX0212, 0x6426}}, + {{CS_UDCJP , 0x384f}, {CS_JISX0212, 0x6371}}, + {{CS_UDCJP , 0x3850}, {CS_JISX0212, 0x6372}}, + {{CS_UDCJP , 0x3851}, {CS_JISX0212, 0x644b}}, + {{CS_UDCJP , 0x3852}, {CS_JISX0212, 0x6441}}, + {{CS_UDCJP , 0x3853}, {CS_JISX0212, 0x6443}}, + {{CS_UDCJP , 0x3854}, {CS_JISX0212, 0x643e}}, + {{CS_UDCJP , 0x3855}, {CS_JISX0212, 0x746f}}, + {{CS_UDCJP , 0x3856}, {CS_JISX0212, 0x6440}}, + {{CS_UDCJP , 0x3857}, {CS_JISX0212, 0x6447}}, + {{CS_UDCJP , 0x3858}, {CS_JISX0212, 0x643f}}, + {{CS_UDCJP , 0x3859}, {CS_JISX0212, 0x6460}}, + {{CS_UDCJP , 0x385a}, {CS_JISX0212, 0x645e}}, + {{CS_UDCJP , 0x385b}, {CS_JISX0212, 0x6451}}, + {{CS_UDCJP , 0x385c}, {CS_JISX0212, 0x7470}}, + {{CS_UDCJP , 0x385d}, {CS_JISX0212, 0x645c}}, + {{CS_UDCJP , 0x385e}, {CS_JISX0212, 0x6452}}, + {{CS_UDCJP , 0x385f}, {CS_JISX0212, 0x645b}}, + {{CS_UDCJP , 0x3860}, {CS_JISX0212, 0x6454}}, + {{CS_UDCJP , 0x3861}, {CS_JISX0212, 0x647a}}, + {{CS_UDCJP , 0x3862}, {CS_JISX0212, 0x646f}}, + {{CS_UDCJP , 0x3863}, {CS_JISX0212, 0x6533}}, + {{CS_UDCJP , 0x3864}, {CS_JISX0212, 0x653f}}, + {{CS_UDCJP , 0x3865}, {CS_JISX0212, 0x6549}}, + {{CS_UDCJP , 0x3866}, {CS_JISX0212, 0x6550}}, + {{CS_UDCJP , 0x3867}, {CS_JISX0212, 0x6562}}, + {{CS_UDCJP , 0x3868}, {CS_JISX0212, 0x656a}}, + {{CS_UDCJP , 0x3869}, {CS_JISX0212, 0x656b}}, + {{CS_UDCJP , 0x386a}, {CS_JISX0212, 0x7471}}, + {{CS_UDCJP , 0x386b}, {CS_JISX0212, 0x7472}}, + {{CS_UDCJP , 0x386c}, {CS_JISX0212, 0x7473}}, + {{CS_UDCJP , 0x386d}, {CS_JISX0212, 0x6668}}, + {{CS_UDCJP , 0x386e}, {CS_JISX0212, 0x666f}}, + {{CS_UDCJP , 0x386f}, {CS_JISX0212, 0x672c}}, + {{CS_UDCJP , 0x3870}, {CS_JISX0212, 0x7474}}, + {{CS_UDCJP , 0x3871}, {CS_JISX0212, 0x672e}}, + {{CS_UDCJP , 0x3872}, {CS_JISX0212, 0x7475}}, + {{CS_UDCJP , 0x3873}, {CS_JISX0212, 0x6731}}, + {{CS_UDCJP , 0x3874}, {CS_JISX0212, 0x7476}}, + {{CS_UDCJP , 0x3875}, {CS_JISX0212, 0x6732}}, + {{CS_UDCJP , 0x3876}, {CS_JISX0212, 0x6831}}, + {{CS_UDCJP , 0x3877}, {CS_JISX0212, 0x6836}}, + {{CS_UDCJP , 0x3878}, {CS_JISX0212, 0x7477}}, + {{CS_UDCJP , 0x3879}, {CS_JISX0212, 0x7478}}, + {{CS_UDCJP , 0x387a}, {CS_JISX0212, 0x685d}}, + {{CS_UDCJP , 0x387b}, {CS_JISX0212, 0x7479}}, + {{CS_UDCJP , 0x387c}, {CS_JISX0212, 0x747a}}, + {{CS_UDCJP , 0x387d}, {CS_JISX0212, 0x6951}}, + {{CS_UDCJP , 0x387e}, {CS_JISX0212, 0x747b}}, + {{CS_UDCJP , 0x3921}, {CS_JISX0212, 0x696d}}, + {{CS_UDCJP , 0x3922}, {CS_JISX0212, 0x6a4d}}, + {{CS_UDCJP , 0x3923}, {CS_JISX0212, 0x747c}}, + {{CS_UDCJP , 0x3924}, {CS_JISX0212, 0x6a5b}}, + {{CS_UDCJP , 0x3925}, {CS_JISX0212, 0x6a66}}, + {{CS_UDCJP , 0x3926}, {CS_JISX0212, 0x6a6a}}, + {{CS_UDCJP , 0x3927}, {CS_JISX0212, 0x6b25}}, + {{CS_UDCJP , 0x3928}, {CS_JISX0212, 0x6b7b}}, + {{CS_UDCJP , 0x3929}, {CS_JISX0212, 0x6b7a}}, + {{CS_UDCJP , 0x392a}, {CS_JISX0212, 0x747d}}, + {{CS_UDCJP , 0x392b}, {CS_JISX0212, 0x6c56}}, + {{CS_UDCJP , 0x392c}, {CS_JISX0212, 0x747e}}, + }; + + /* + * NEC extended kanji translaton table + */ + + static MAP map_nec_sjis_jisx0208_to_euc[] = { + {{CS_JISX0208, 0x7921}, {CS_JISX0212, 0x5463}}, + {{CS_JISX0208, 0x7922}, {CS_JISX0212, 0x5c5f}}, + {{CS_JISX0208, 0x7923}, {CS_JISX0212, 0x6469}}, + {{CS_JISX0208, 0x7924}, {CS_JISX0212, 0x6378}}, + {{CS_JISX0208, 0x7925}, {CS_JISX0212, 0x5921}}, + {{CS_JISX0208, 0x7926}, {CS_JISX0212, 0x313b}}, + {{CS_JISX0208, 0x7927}, {CS_JISX0212, 0x742e}}, + {{CS_JISX0208, 0x7928}, {CS_JISX0212, 0x422d}}, + {{CS_JISX0208, 0x7929}, {CS_JISX0212, 0x437c}}, + {{CS_JISX0208, 0x792a}, {CS_JISX0212, 0x6450}}, + {{CS_JISX0208, 0x792b}, {CS_JISX0212, 0x423f}}, + {{CS_JISX0208, 0x792c}, {CS_JISX0212, 0x3c74}}, + {{CS_JISX0208, 0x792d}, {CS_JISX0212, 0x3029}}, + {{CS_JISX0208, 0x792e}, {CS_JISX0212, 0x3048}}, + {{CS_JISX0208, 0x792f}, {CS_JISX0212, 0x742f}}, + {{CS_JISX0208, 0x7930}, {CS_JISX0212, 0x3052}}, + {{CS_JISX0208, 0x7931}, {CS_JISX0212, 0x3054}}, + {{CS_JISX0208, 0x7932}, {CS_JISX0212, 0x3063}}, + {{CS_JISX0208, 0x7933}, {CS_JISX0212, 0x306e}}, + {{CS_JISX0208, 0x7934}, {CS_JISX0212, 0x3127}}, + {{CS_JISX0208, 0x7935}, {CS_JISX0212, 0x3123}}, + {{CS_JISX0208, 0x7936}, {CS_JISX0212, 0x312c}}, + {{CS_JISX0208, 0x7937}, {CS_JISX0212, 0x3129}}, + {{CS_JISX0208, 0x7938}, {CS_JISX0212, 0x313e}}, + {{CS_JISX0208, 0x7939}, {CS_JISX0212, 0x315f}}, + {{CS_JISX0208, 0x793a}, {CS_JISX0212, 0x3158}}, + {{CS_JISX0208, 0x793b}, {CS_JISX0212, 0x3148}}, + {{CS_JISX0208, 0x793c}, {CS_JISX0212, 0x3157}}, + {{CS_JISX0208, 0x793d}, {CS_JISX0212, 0x3163}}, + {{CS_JISX0208, 0x793e}, {CS_JISX0212, 0x3174}}, + {{CS_JISX0208, 0x793f}, {CS_JISX0212, 0x3161}}, + {{CS_JISX0208, 0x7940}, {CS_JISX0212, 0x3223}}, + {{CS_JISX0208, 0x7941}, {CS_JISX0212, 0x7430}}, + {{CS_JISX0208, 0x7942}, {CS_JISX0212, 0x323b}}, + {{CS_JISX0208, 0x7943}, {CS_JISX0212, 0x3266}}, + {{CS_JISX0208, 0x7944}, {CS_JISX0212, 0x326d}}, + {{CS_JISX0208, 0x7945}, {CS_JISX0212, 0x3275}}, + {{CS_JISX0208, 0x7946}, {CS_JISX0212, 0x327c}}, + {{CS_JISX0208, 0x7947}, {CS_JISX0212, 0x7431}}, + {{CS_JISX0208, 0x7948}, {CS_JISX0212, 0x3335}}, + {{CS_JISX0208, 0x7949}, {CS_JISX0212, 0x3358}}, + {{CS_JISX0208, 0x794a}, {CS_JISX0212, 0x335b}}, + {{CS_JISX0208, 0x794b}, {CS_JISX0212, 0x3365}}, + {{CS_JISX0208, 0x794c}, {CS_JISX0212, 0x336e}}, + {{CS_JISX0208, 0x794d}, {CS_JISX0212, 0x337b}}, + {{CS_JISX0208, 0x794e}, {CS_JISX0212, 0x7432}}, + {{CS_JISX0208, 0x794f}, {CS_JISX0212, 0x7433}}, + {{CS_JISX0208, 0x7950}, {CS_JISX0212, 0x3440}}, + {{CS_JISX0208, 0x7951}, {CS_JISX0212, 0x3447}}, + {{CS_JISX0208, 0x7952}, {CS_JISX0212, 0x3450}}, + {{CS_JISX0208, 0x7953}, {CS_JISX0212, 0x345e}}, + {{CS_JISX0208, 0x7954}, {CS_JISX0212, 0x7434}}, + {{CS_JISX0208, 0x7955}, {CS_JISX0212, 0x352a}}, + {{CS_JISX0208, 0x7956}, {CS_JISX0212, 0x7435}}, + {{CS_JISX0208, 0x7957}, {CS_JISX0212, 0x352f}}, + {{CS_JISX0208, 0x7958}, {CS_JISX0212, 0x3544}}, + {{CS_JISX0208, 0x7959}, {CS_JISX0212, 0x3568}}, + {{CS_JISX0208, 0x795a}, {CS_JISX0212, 0x7436}}, + {{CS_JISX0208, 0x795b}, {CS_JISX0212, 0x3742}}, + {{CS_JISX0208, 0x795c}, {CS_JISX0212, 0x3764}}, + {{CS_JISX0208, 0x795d}, {CS_JISX0212, 0x3768}}, + {{CS_JISX0208, 0x795e}, {CS_JISX0212, 0x3767}}, + {{CS_JISX0208, 0x795f}, {CS_JISX0212, 0x7437}}, + {{CS_JISX0208, 0x7960}, {CS_JISX0212, 0x7438}}, + {{CS_JISX0208, 0x7961}, {CS_JISX0212, 0x7439}}, + {{CS_JISX0208, 0x7962}, {CS_JISX0212, 0x384e}}, + {{CS_JISX0208, 0x7963}, {CS_JISX0212, 0x3861}}, + {{CS_JISX0208, 0x7964}, {CS_JISX0212, 0x3875}}, + {{CS_JISX0208, 0x7965}, {CS_JISX0212, 0x3877}}, + {{CS_JISX0208, 0x7966}, {CS_JISX0212, 0x3878}}, + {{CS_JISX0208, 0x7967}, {CS_JISX0212, 0x387c}}, + {{CS_JISX0208, 0x7968}, {CS_JISX0212, 0x392f}}, + {{CS_JISX0208, 0x7969}, {CS_JISX0212, 0x3937}}, + {{CS_JISX0208, 0x796a}, {CS_JISX0212, 0x3a3e}}, + {{CS_JISX0208, 0x796b}, {CS_JISX0212, 0x3a5b}}, + {{CS_JISX0208, 0x796c}, {CS_JISX0212, 0x4d2a}}, + {{CS_JISX0208, 0x796d}, {CS_JISX0212, 0x3a61}}, + {{CS_JISX0208, 0x796e}, {CS_JISX0212, 0x743a}}, + {{CS_JISX0208, 0x796f}, {CS_JISX0212, 0x3a6b}}, + {{CS_JISX0208, 0x7970}, {CS_JISX0212, 0x3b33}}, + {{CS_JISX0208, 0x7971}, {CS_JISX0212, 0x3b38}}, + {{CS_JISX0208, 0x7972}, {CS_JISX0212, 0x743b}}, + {{CS_JISX0208, 0x7973}, {CS_JISX0212, 0x3b4a}}, + {{CS_JISX0208, 0x7974}, {CS_JISX0212, 0x743c}}, + {{CS_JISX0208, 0x7975}, {CS_JISX0212, 0x743d}}, + {{CS_JISX0208, 0x7976}, {CS_JISX0212, 0x3b50}}, + {{CS_JISX0208, 0x7977}, {CS_JISX0212, 0x3b5e}}, + {{CS_JISX0208, 0x7978}, {CS_JISX0212, 0x3b74}}, + {{CS_JISX0208, 0x7979}, {CS_JISX0212, 0x3b75}}, + {{CS_JISX0208, 0x797a}, {CS_JISX0212, 0x3b79}}, + {{CS_JISX0208, 0x797b}, {CS_JISX0212, 0x3c64}}, + {{CS_JISX0208, 0x797c}, {CS_JISX0212, 0x3c6d}}, + {{CS_JISX0208, 0x797d}, {CS_JISX0212, 0x3c7e}}, + {{CS_JISX0208, 0x797e}, {CS_JISX0212, 0x743e}}, + {{CS_JISX0208, 0x7a21}, {CS_JISX0212, 0x3d42}}, + {{CS_JISX0208, 0x7a22}, {CS_JISX0212, 0x3d67}}, + {{CS_JISX0208, 0x7a23}, {CS_JISX0212, 0x743f}}, + {{CS_JISX0208, 0x7a24}, {CS_JISX0212, 0x3d70}}, + {{CS_JISX0208, 0x7a25}, {CS_JISX0212, 0x3e30}}, + {{CS_JISX0208, 0x7a26}, {CS_JISX0212, 0x3e2c}}, + {{CS_JISX0208, 0x7a27}, {CS_JISX0212, 0x7440}}, + {{CS_JISX0208, 0x7a28}, {CS_JISX0212, 0x3e33}}, + {{CS_JISX0208, 0x7a29}, {CS_JISX0212, 0x3e3d}}, + {{CS_JISX0208, 0x7a2a}, {CS_JISX0212, 0x3e4d}}, + {{CS_JISX0208, 0x7a2b}, {CS_JISX0212, 0x3e49}}, + {{CS_JISX0208, 0x7a2c}, {CS_JISX0212, 0x3e64}}, + {{CS_JISX0208, 0x7a2d}, {CS_JISX0212, 0x3f28}}, + {{CS_JISX0208, 0x7a2e}, {CS_JISX0212, 0x3f49}}, + {{CS_JISX0208, 0x7a2f}, {CS_JISX0212, 0x4044}}, + {{CS_JISX0208, 0x7a30}, {CS_JISX0212, 0x4064}}, + {{CS_JISX0208, 0x7a31}, {CS_JISX0212, 0x4074}}, + {{CS_JISX0208, 0x7a32}, {CS_JISX0212, 0x4126}}, + {{CS_JISX0208, 0x7a33}, {CS_JISX0212, 0x7441}}, + {{CS_JISX0208, 0x7a34}, {CS_JISX0212, 0x4175}}, + {{CS_JISX0208, 0x7a35}, {CS_JISX0212, 0x417c}}, + {{CS_JISX0208, 0x7a36}, {CS_JISX0212, 0x7442}}, + {{CS_JISX0208, 0x7a37}, {CS_JISX0212, 0x4178}}, + {{CS_JISX0208, 0x7a38}, {CS_JISX0212, 0x422b}}, + {{CS_JISX0208, 0x7a39}, {CS_JISX0212, 0x4221}}, + {{CS_JISX0208, 0x7a3a}, {CS_JISX0212, 0x4225}}, + {{CS_JISX0208, 0x7a3b}, {CS_JISX0212, 0x7443}}, + {{CS_JISX0208, 0x7a3c}, {CS_JISX0212, 0x4238}}, + {{CS_JISX0208, 0x7a3d}, {CS_JISX0212, 0x423a}}, + {{CS_JISX0208, 0x7a3e}, {CS_JISX0212, 0x7444}}, + {{CS_JISX0208, 0x7a3f}, {CS_JISX0212, 0x4244}}, + {{CS_JISX0208, 0x7a40}, {CS_JISX0212, 0x4252}}, + {{CS_JISX0208, 0x7a41}, {CS_JISX0212, 0x4257}}, + {{CS_JISX0208, 0x7a42}, {CS_JISX0212, 0x425b}}, + {{CS_JISX0208, 0x7a43}, {CS_JISX0212, 0x425e}}, + {{CS_JISX0208, 0x7a44}, {CS_JISX0212, 0x426d}}, + {{CS_JISX0208, 0x7a45}, {CS_JISX0212, 0x4270}}, + {{CS_JISX0208, 0x7a46}, {CS_JISX0212, 0x7445}}, + {{CS_JISX0208, 0x7a47}, {CS_JISX0212, 0x4321}}, + {{CS_JISX0208, 0x7a48}, {CS_JISX0212, 0x4335}}, + {{CS_JISX0208, 0x7a49}, {CS_JISX0212, 0x4349}}, + {{CS_JISX0208, 0x7a4a}, {CS_JISX0212, 0x4339}}, + {{CS_JISX0208, 0x7a4b}, {CS_JISX0212, 0x7446}}, + {{CS_JISX0208, 0x7a4c}, {CS_JISX0212, 0x4358}}, + {{CS_JISX0208, 0x7a4d}, {CS_JISX0212, 0x437e}}, + {{CS_JISX0208, 0x7a4e}, {CS_JISX0212, 0x7447}}, + {{CS_JISX0208, 0x7a4f}, {CS_JISX0212, 0x444c}}, + {{CS_JISX0208, 0x7a50}, {CS_JISX0212, 0x7448}}, + {{CS_JISX0208, 0x7a51}, {CS_JISX0212, 0x4459}}, + {{CS_JISX0208, 0x7a52}, {CS_JISX0212, 0x446a}}, + {{CS_JISX0208, 0x7a53}, {CS_JISX0212, 0x447d}}, + {{CS_JISX0208, 0x7a54}, {CS_JISX0212, 0x7449}}, + {{CS_JISX0208, 0x7a55}, {CS_JISX0212, 0x4527}}, + {{CS_JISX0208, 0x7a56}, {CS_JISX0212, 0x4535}}, + {{CS_JISX0208, 0x7a57}, {CS_JISX0212, 0x4536}}, + {{CS_JISX0208, 0x7a58}, {CS_JISX0212, 0x744a}}, + {{CS_JISX0208, 0x7a59}, {CS_JISX0212, 0x4555}}, + {{CS_JISX0208, 0x7a5a}, {CS_JISX0212, 0x4638}}, + {{CS_JISX0208, 0x7a5b}, {CS_JISX0212, 0x4657}}, + {{CS_JISX0208, 0x7a5c}, {CS_JISX0212, 0x4660}}, + {{CS_JISX0208, 0x7a5d}, {CS_JISX0212, 0x466a}}, + {{CS_JISX0208, 0x7a5e}, {CS_JISX0212, 0x4663}}, + {{CS_JISX0208, 0x7a5f}, {CS_JISX0212, 0x4721}}, + {{CS_JISX0208, 0x7a60}, {CS_JISX0212, 0x472b}}, + {{CS_JISX0208, 0x7a61}, {CS_JISX0212, 0x4747}}, + {{CS_JISX0208, 0x7a62}, {CS_JISX0212, 0x4743}}, + {{CS_JISX0208, 0x7a63}, {CS_JISX0212, 0x474b}}, + {{CS_JISX0208, 0x7a64}, {CS_JISX0212, 0x474f}}, + {{CS_JISX0208, 0x7a65}, {CS_JISX0212, 0x4759}}, + {{CS_JISX0208, 0x7a66}, {CS_JISX0212, 0x744b}}, + {{CS_JISX0208, 0x7a67}, {CS_JISX0212, 0x744c}}, + {{CS_JISX0208, 0x7a68}, {CS_JISX0212, 0x4766}}, + {{CS_JISX0208, 0x7a69}, {CS_JISX0212, 0x476e}}, + {{CS_JISX0208, 0x7a6a}, {CS_JISX0212, 0x477c}}, + {{CS_JISX0208, 0x7a6b}, {CS_JISX0212, 0x476b}}, + {{CS_JISX0208, 0x7a6c}, {CS_JISX0212, 0x4770}}, + {{CS_JISX0208, 0x7a6d}, {CS_JISX0212, 0x4831}}, + {{CS_JISX0208, 0x7a6e}, {CS_JISX0212, 0x4865}}, + {{CS_JISX0208, 0x7a6f}, {CS_JISX0212, 0x4878}}, + {{CS_JISX0208, 0x7a70}, {CS_JISX0212, 0x4926}}, + {{CS_JISX0208, 0x7a71}, {CS_JISX0212, 0x492b}}, + {{CS_JISX0208, 0x7a72}, {CS_JISX0212, 0x492d}}, + {{CS_JISX0208, 0x7a73}, {CS_JISX0212, 0x744d}}, + {{CS_JISX0208, 0x7a74}, {CS_JISX0212, 0x494a}}, + {{CS_JISX0208, 0x7a75}, {CS_JISX0212, 0x4953}}, + {{CS_JISX0208, 0x7a76}, {CS_JISX0212, 0x4969}}, + {{CS_JISX0208, 0x7a77}, {CS_JISX0212, 0x4963}}, + {{CS_JISX0208, 0x7a78}, {CS_JISX0212, 0x497c}}, + {{CS_JISX0208, 0x7a79}, {CS_JISX0212, 0x4974}}, + {{CS_JISX0208, 0x7a7a}, {CS_JISX0212, 0x4975}}, + {{CS_JISX0208, 0x7a7b}, {CS_JISX0212, 0x744e}}, + {{CS_JISX0208, 0x7a7c}, {CS_JISX0212, 0x4a33}}, + {{CS_JISX0208, 0x7a7d}, {CS_JISX0212, 0x4a3d}}, + {{CS_JISX0208, 0x7a7e}, {CS_JISX0212, 0x4a6f}}, + {{CS_JISX0208, 0x7b21}, {CS_JISX0212, 0x4a71}}, + {{CS_JISX0208, 0x7b22}, {CS_JISX0212, 0x4b2e}}, + {{CS_JISX0208, 0x7b23}, {CS_JISX0212, 0x744f}}, + {{CS_JISX0208, 0x7b24}, {CS_JISX0212, 0x4b4a}}, + {{CS_JISX0208, 0x7b25}, {CS_JISX0212, 0x4b66}}, + {{CS_JISX0208, 0x7b26}, {CS_JISX0212, 0x4b6a}}, + {{CS_JISX0208, 0x7b27}, {CS_JISX0212, 0x4b70}}, + {{CS_JISX0208, 0x7b28}, {CS_JISX0212, 0x4b74}}, + {{CS_JISX0208, 0x7b29}, {CS_JISX0212, 0x4b6e}}, + {{CS_JISX0208, 0x7b2a}, {CS_JISX0212, 0x4c25}}, + {{CS_JISX0208, 0x7b2b}, {CS_JISX0212, 0x4b79}}, + {{CS_JISX0208, 0x7b2c}, {CS_JISX0212, 0x4c2b}}, + {{CS_JISX0208, 0x7b2d}, {CS_JISX0212, 0x4c2e}}, + {{CS_JISX0208, 0x7b2e}, {CS_JISX0212, 0x4c2d}}, + {{CS_JISX0208, 0x7b2f}, {CS_JISX0212, 0x4c32}}, + {{CS_JISX0208, 0x7b30}, {CS_JISX0212, 0x4c42}}, + {{CS_JISX0208, 0x7b31}, {CS_JISX0212, 0x4c50}}, + {{CS_JISX0208, 0x7b32}, {CS_JISX0212, 0x4c59}}, + {{CS_JISX0208, 0x7b33}, {CS_JISX0212, 0x7450}}, + {{CS_JISX0208, 0x7b34}, {CS_JISX0212, 0x4d3b}}, + {{CS_JISX0208, 0x7b35}, {CS_JISX0212, 0x7451}}, + {{CS_JISX0208, 0x7b36}, {CS_JISX0212, 0x4e3b}}, + {{CS_JISX0208, 0x7b37}, {CS_JISX0212, 0x7452}}, + {{CS_JISX0208, 0x7b38}, {CS_JISX0212, 0x4e3a}}, + {{CS_JISX0208, 0x7b39}, {CS_JISX0212, 0x4e43}}, + {{CS_JISX0208, 0x7b3a}, {CS_JISX0212, 0x7453}}, + {{CS_JISX0208, 0x7b3b}, {CS_JISX0212, 0x4e72}}, + {{CS_JISX0208, 0x7b3c}, {CS_JISX0212, 0x335d}}, + {{CS_JISX0208, 0x7b3d}, {CS_JISX0212, 0x4f55}}, + {{CS_JISX0208, 0x7b3e}, {CS_JISX0212, 0x4f62}}, + {{CS_JISX0208, 0x7b3f}, {CS_JISX0212, 0x4f69}}, + {{CS_JISX0208, 0x7b40}, {CS_JISX0212, 0x4f6d}}, + {{CS_JISX0208, 0x7b41}, {CS_JISX0212, 0x7454}}, + {{CS_JISX0208, 0x7b42}, {CS_JISX0212, 0x7455}}, + {{CS_JISX0208, 0x7b43}, {CS_JISX0212, 0x7456}}, + {{CS_JISX0208, 0x7b44}, {CS_JISX0212, 0x7457}}, + {{CS_JISX0208, 0x7b45}, {CS_JISX0212, 0x5065}}, + {{CS_JISX0208, 0x7b46}, {CS_JISX0212, 0x7458}}, + {{CS_JISX0208, 0x7b47}, {CS_JISX0212, 0x5069}}, + {{CS_JISX0208, 0x7b48}, {CS_JISX0212, 0x5168}}, + {{CS_JISX0208, 0x7b49}, {CS_JISX0212, 0x7459}}, + {{CS_JISX0208, 0x7b4a}, {CS_JISX0212, 0x745a}}, + {{CS_JISX0208, 0x7b4b}, {CS_JISX0212, 0x516c}}, + {{CS_JISX0208, 0x7b4c}, {CS_JISX0212, 0x523b}}, + {{CS_JISX0208, 0x7b4d}, {CS_JISX0212, 0x745b}}, + {{CS_JISX0208, 0x7b4e}, {CS_JISX0212, 0x5361}}, + {{CS_JISX0208, 0x7b4f}, {CS_JISX0212, 0x5368}}, + {{CS_JISX0208, 0x7b50}, {CS_JISX0212, 0x5427}}, + {{CS_JISX0208, 0x7b51}, {CS_JISX0212, 0x745c}}, + {{CS_JISX0208, 0x7b52}, {CS_JISX0212, 0x745d}}, + {{CS_JISX0208, 0x7b53}, {CS_JISX0212, 0x5454}}, + {{CS_JISX0208, 0x7b54}, {CS_JISX0212, 0x5472}}, + {{CS_JISX0208, 0x7b55}, {CS_JISX0212, 0x552e}}, + {{CS_JISX0208, 0x7b56}, {CS_JISX0212, 0x745e}}, + {{CS_JISX0208, 0x7b57}, {CS_JISX0212, 0x575e}}, + {{CS_JISX0208, 0x7b58}, {CS_JISX0212, 0x745f}}, + {{CS_JISX0208, 0x7b59}, {CS_JISX0212, 0x5822}}, + {{CS_JISX0208, 0x7b5a}, {CS_JISX0212, 0x5837}}, + {{CS_JISX0208, 0x7b5b}, {CS_JISX0212, 0x5841}}, + {{CS_JISX0208, 0x7b5c}, {CS_JISX0212, 0x5851}}, + {{CS_JISX0208, 0x7b5d}, {CS_JISX0212, 0x5874}}, + {{CS_JISX0208, 0x7b5e}, {CS_JISX0212, 0x5946}}, + {{CS_JISX0208, 0x7b5f}, {CS_JISX0212, 0x5948}}, + {{CS_JISX0208, 0x7b60}, {CS_JISX0212, 0x5951}}, + {{CS_JISX0208, 0x7b61}, {CS_JISX0212, 0x7460}}, + {{CS_JISX0208, 0x7b62}, {CS_JISX0212, 0x7461}}, + {{CS_JISX0208, 0x7b63}, {CS_JISX0212, 0x7462}}, + {{CS_JISX0208, 0x7b64}, {CS_JISX0212, 0x7463}}, + {{CS_JISX0208, 0x7b65}, {CS_JISX0212, 0x7464}}, + {{CS_JISX0208, 0x7b66}, {CS_JISX0212, 0x5c53}}, + {{CS_JISX0208, 0x7b67}, {CS_JISX0212, 0x5d48}}, + {{CS_JISX0208, 0x7b68}, {CS_JISX0212, 0x5d54}}, + {{CS_JISX0208, 0x7b69}, {CS_JISX0212, 0x5d6a}}, + {{CS_JISX0208, 0x7b6a}, {CS_JISX0212, 0x5d7a}}, + {{CS_JISX0208, 0x7b6b}, {CS_JISX0212, 0x5e24}}, + {{CS_JISX0208, 0x7b6c}, {CS_JISX0212, 0x5e30}}, + {{CS_JISX0208, 0x7b6d}, {CS_JISX0212, 0x7465}}, + {{CS_JISX0208, 0x7b6e}, {CS_JISX0212, 0x5e35}}, + {{CS_JISX0208, 0x7b6f}, {CS_JISX0212, 0x5e4b}}, + {{CS_JISX0208, 0x7b70}, {CS_JISX0212, 0x7466}}, + {{CS_JISX0208, 0x7b71}, {CS_JISX0212, 0x5f39}}, + {{CS_JISX0208, 0x7b72}, {CS_JISX0212, 0x7467}}, + {{CS_JISX0208, 0x7b73}, {CS_JISX0212, 0x5f43}}, + {{CS_JISX0208, 0x7b74}, {CS_JISX0212, 0x7468}}, + {{CS_JISX0208, 0x7b75}, {CS_JISX0212, 0x7469}}, + {{CS_JISX0208, 0x7b76}, {CS_JISX0212, 0x6059}}, + {{CS_JISX0208, 0x7b77}, {CS_JISX0212, 0x746a}}, + {{CS_JISX0208, 0x7b78}, {CS_JISX0212, 0x746b}}, + {{CS_JISX0208, 0x7b79}, {CS_JISX0212, 0x6162}}, + {{CS_JISX0208, 0x7b7a}, {CS_JISX0212, 0x746c}}, + {{CS_JISX0208, 0x7b7b}, {CS_JISX0212, 0x746d}}, + {{CS_JISX0208, 0x7b7c}, {CS_JISX0212, 0x746e}}, + {{CS_JISX0208, 0x7b7d}, {CS_JISX0212, 0x6247}}, + {{CS_JISX0208, 0x7b7e}, {CS_JISX0212, 0x6328}}, + {{CS_JISX0208, 0x7c21}, {CS_JISX0212, 0x6326}}, + {{CS_JISX0208, 0x7c22}, {CS_JISX0212, 0x6329}}, + {{CS_JISX0208, 0x7c23}, {CS_JISX0212, 0x632f}}, + {{CS_JISX0208, 0x7c24}, {CS_JISX0212, 0x6330}}, + {{CS_JISX0208, 0x7c25}, {CS_JISX0212, 0x632a}}, + {{CS_JISX0208, 0x7c26}, {CS_JISX0212, 0x632b}}, + {{CS_JISX0208, 0x7c27}, {CS_JISX0212, 0x633c}}, + {{CS_JISX0208, 0x7c28}, {CS_JISX0212, 0x6341}}, + {{CS_JISX0208, 0x7c29}, {CS_JISX0212, 0x633f}}, + {{CS_JISX0208, 0x7c2a}, {CS_JISX0212, 0x6355}}, + {{CS_JISX0208, 0x7c2b}, {CS_JISX0212, 0x6358}}, + {{CS_JISX0208, 0x7c2c}, {CS_JISX0212, 0x6356}}, + {{CS_JISX0208, 0x7c2d}, {CS_JISX0212, 0x635f}}, + {{CS_JISX0208, 0x7c2e}, {CS_JISX0212, 0x6363}}, + {{CS_JISX0208, 0x7c2f}, {CS_JISX0212, 0x6361}}, + {{CS_JISX0208, 0x7c30}, {CS_JISX0212, 0x6354}}, + {{CS_JISX0208, 0x7c31}, {CS_JISX0212, 0x6369}}, + {{CS_JISX0208, 0x7c32}, {CS_JISX0212, 0x6426}}, + {{CS_JISX0208, 0x7c33}, {CS_JISX0212, 0x6371}}, + {{CS_JISX0208, 0x7c34}, {CS_JISX0212, 0x6372}}, + {{CS_JISX0208, 0x7c35}, {CS_JISX0212, 0x644b}}, + {{CS_JISX0208, 0x7c36}, {CS_JISX0212, 0x6441}}, + {{CS_JISX0208, 0x7c37}, {CS_JISX0212, 0x6443}}, + {{CS_JISX0208, 0x7c38}, {CS_JISX0212, 0x643e}}, + {{CS_JISX0208, 0x7c39}, {CS_JISX0212, 0x746f}}, + {{CS_JISX0208, 0x7c3a}, {CS_JISX0212, 0x6440}}, + {{CS_JISX0208, 0x7c3b}, {CS_JISX0212, 0x6447}}, + {{CS_JISX0208, 0x7c3c}, {CS_JISX0212, 0x643f}}, + {{CS_JISX0208, 0x7c3d}, {CS_JISX0212, 0x6460}}, + {{CS_JISX0208, 0x7c3e}, {CS_JISX0212, 0x645e}}, + {{CS_JISX0208, 0x7c3f}, {CS_JISX0212, 0x6451}}, + {{CS_JISX0208, 0x7c40}, {CS_JISX0212, 0x7470}}, + {{CS_JISX0208, 0x7c41}, {CS_JISX0212, 0x645c}}, + {{CS_JISX0208, 0x7c42}, {CS_JISX0212, 0x6452}}, + {{CS_JISX0208, 0x7c43}, {CS_JISX0212, 0x645b}}, + {{CS_JISX0208, 0x7c44}, {CS_JISX0212, 0x6454}}, + {{CS_JISX0208, 0x7c45}, {CS_JISX0212, 0x647a}}, + {{CS_JISX0208, 0x7c46}, {CS_JISX0212, 0x646f}}, + {{CS_JISX0208, 0x7c47}, {CS_JISX0212, 0x6533}}, + {{CS_JISX0208, 0x7c48}, {CS_JISX0212, 0x653f}}, + {{CS_JISX0208, 0x7c49}, {CS_JISX0212, 0x6549}}, + {{CS_JISX0208, 0x7c4a}, {CS_JISX0212, 0x6550}}, + {{CS_JISX0208, 0x7c4b}, {CS_JISX0212, 0x6562}}, + {{CS_JISX0208, 0x7c4c}, {CS_JISX0212, 0x656a}}, + {{CS_JISX0208, 0x7c4d}, {CS_JISX0212, 0x656b}}, + {{CS_JISX0208, 0x7c4e}, {CS_JISX0212, 0x7471}}, + {{CS_JISX0208, 0x7c4f}, {CS_JISX0212, 0x7472}}, + {{CS_JISX0208, 0x7c50}, {CS_JISX0212, 0x7473}}, + {{CS_JISX0208, 0x7c51}, {CS_JISX0212, 0x6668}}, + {{CS_JISX0208, 0x7c52}, {CS_JISX0212, 0x666f}}, + {{CS_JISX0208, 0x7c53}, {CS_JISX0212, 0x672c}}, + {{CS_JISX0208, 0x7c54}, {CS_JISX0212, 0x7474}}, + {{CS_JISX0208, 0x7c55}, {CS_JISX0212, 0x672e}}, + {{CS_JISX0208, 0x7c56}, {CS_JISX0212, 0x7475}}, + {{CS_JISX0208, 0x7c57}, {CS_JISX0212, 0x6731}}, + {{CS_JISX0208, 0x7c58}, {CS_JISX0212, 0x7476}}, + {{CS_JISX0208, 0x7c59}, {CS_JISX0212, 0x6732}}, + {{CS_JISX0208, 0x7c5a}, {CS_JISX0212, 0x6831}}, + {{CS_JISX0208, 0x7c5b}, {CS_JISX0212, 0x6836}}, + {{CS_JISX0208, 0x7c5c}, {CS_JISX0212, 0x7477}}, + {{CS_JISX0208, 0x7c5d}, {CS_JISX0212, 0x7478}}, + {{CS_JISX0208, 0x7c5e}, {CS_JISX0212, 0x685d}}, + {{CS_JISX0208, 0x7c5f}, {CS_JISX0212, 0x7479}}, + {{CS_JISX0208, 0x7c60}, {CS_JISX0212, 0x747a}}, + {{CS_JISX0208, 0x7c61}, {CS_JISX0212, 0x6951}}, + {{CS_JISX0208, 0x7c62}, {CS_JISX0212, 0x747b}}, + {{CS_JISX0208, 0x7c63}, {CS_JISX0212, 0x696d}}, + {{CS_JISX0208, 0x7c64}, {CS_JISX0212, 0x6a4d}}, + {{CS_JISX0208, 0x7c65}, {CS_JISX0212, 0x747c}}, + {{CS_JISX0208, 0x7c66}, {CS_JISX0212, 0x6a5b}}, + {{CS_JISX0208, 0x7c67}, {CS_JISX0212, 0x6a66}}, + {{CS_JISX0208, 0x7c68}, {CS_JISX0212, 0x6a6a}}, + {{CS_JISX0208, 0x7c69}, {CS_JISX0212, 0x6b25}}, + {{CS_JISX0208, 0x7c6a}, {CS_JISX0212, 0x6b7b}}, + {{CS_JISX0208, 0x7c6b}, {CS_JISX0212, 0x6b7a}}, + {{CS_JISX0208, 0x7c6c}, {CS_JISX0212, 0x747d}}, + {{CS_JISX0208, 0x7c6d}, {CS_JISX0212, 0x6c56}}, + {{CS_JISX0208, 0x7c6e}, {CS_JISX0212, 0x747e}}, + {{CS_JISX0208, 0x7c71}, {CS_JISX0212, 0x7373}}, + {{CS_JISX0208, 0x7c72}, {CS_JISX0212, 0x7374}}, + {{CS_JISX0208, 0x7c73}, {CS_JISX0212, 0x7375}}, + {{CS_JISX0208, 0x7c74}, {CS_JISX0212, 0x7376}}, + {{CS_JISX0208, 0x7c75}, {CS_JISX0212, 0x7377}}, + {{CS_JISX0208, 0x7c76}, {CS_JISX0212, 0x7378}}, + {{CS_JISX0208, 0x7c77}, {CS_JISX0212, 0x7379}}, + {{CS_JISX0208, 0x7c78}, {CS_JISX0212, 0x737a}}, + {{CS_JISX0208, 0x7c79}, {CS_JISX0212, 0x737b}}, + {{CS_JISX0208, 0x7c7a}, {CS_JISX0212, 0x737c}}, + {{CS_JISX0208, 0x7c7b}, {CS_JISX0208, 0x224c}}, + {{CS_JISX0208, 0x7c7c}, {CS_JISX0212, 0x2243}}, + {{CS_JISX0208, 0x7c7d}, {CS_JISX0212, 0x7429}}, + {{CS_JISX0208, 0x7c7e}, {CS_JISX0212, 0x742a}}, + }; Index: psqlodbc/psqlodbc.rc diff -c psqlodbc/psqlodbc.rc:1.1.1.5 psqlodbc/psqlodbc.rc:1.1.1.5.2.1 *** psqlodbc/psqlodbc.rc:1.1.1.5 Fri Jul 13 20:24:20 2001 --- psqlodbc/psqlodbc.rc Fri Jul 13 23:05:13 2001 *************** *** 362,378 **** --- 362,390 ---- #ifdef MULTIBYTE VALUE "CompanyName", "Insight Distribution Systems & Sankyo Unyu Service (MULTIBYTE support)\0" #else + #ifdef KANJI + VALUE "CompanyName", "Insight Distribution Systems, localized by InterWIZ\0" + #else VALUE "CompanyName", "Insight Distribution Systems\0" #endif + #endif VALUE "FileDescription", "PostgreSQL Driver\0" + #ifdef KANJI + VALUE "FileVersion", " 07.01.0006.20010713\0" + #else VALUE "FileVersion", " 07.01.0006\0" + #endif VALUE "InternalName", "psqlodbc\0" VALUE "LegalCopyright", "\0" VALUE "LegalTrademarks", "ODBC(TM) is a trademark of Microsoft Corporation. Microsoft® is a registered trademark of Microsoft Corporation. Windows(TM) is a trademark of Microsoft Corporation.\0" VALUE "OriginalFilename", "psqlodbc.dll\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "Microsoft Open Database Connectivity\0" + #ifdef KANJI + VALUE "ProductVersion", " 07.01.0006.20010713\0" + #else VALUE "ProductVersion", " 07.01.0006\0" + #endif VALUE "SpecialBuild", "\0" END END Index: psqlodbc/results.c diff -c psqlodbc/results.c:1.1.1.5 psqlodbc/results.c:1.1.1.5.2.1 *** psqlodbc/results.c:1.1.1.5 Fri Jul 13 20:24:23 2001 --- psqlodbc/results.c Fri Jul 13 23:05:13 2001 *************** *** 39,44 **** --- 39,47 ---- #include #include #endif + #ifdef KANJI + #include "kanji.h" + #endif /* KANJI */ extern GLOBAL_VALUES globals; *************** *** 296,301 **** --- 299,313 ---- /* * COLUMN NAME */ + #ifdef KANJI + col_name = euc_to_sjis(col_name, SQL_NTS); + if (! col_name) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + #endif /* KANJI */ len = strlen(col_name); if (pcbColName) *************** *** 312,317 **** --- 324,333 ---- stmt->errormsg = "The buffer was too small for the colName."; } } + #ifdef KANJI + if (col_name) + free(col_name); + #endif /* KANJI */ /* * SQL TYPE *************** *** 609,614 **** --- 625,639 ---- if (p) { /* char/binary data */ + #ifdef KANJI + p = euc_to_sjis(p, SQL_NTS); + if ( ! p) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + #endif /* KANJI */ len = strlen(p); if (rgbDesc) *************** *** 625,630 **** --- 650,658 ---- if (pcbDesc) *pcbDesc = len; + #ifdef KANJI + free(p); + #endif /* KANJI */ } else { *************** *** 1297,1302 **** --- 1325,1340 ---- return SQL_INVALID_HANDLE; } + #ifdef KANJI + szCursor = sjis_to_euc(szCursor, cbCursor); + if ( ! szCursor) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + cbCursor = SQL_NTS; + #endif /* KANJI */ len = (cbCursor == SQL_NTS) ? strlen(szCursor) : cbCursor; if (len <= 0 || len > sizeof(stmt->cursor_name) - 1) *************** *** 1304,1313 **** --- 1342,1357 ---- stmt->errornumber = STMT_INVALID_CURSOR_NAME; stmt->errormsg = "Invalid Cursor Name"; SC_log_error(func, "", stmt); + #ifdef KANJI + free(szCursor); + #endif /* KANJI */ return SQL_ERROR; } strncpy_null(stmt->cursor_name, szCursor, len + 1); + #ifdef KANJI + free(szCursor); + #endif /* KANJI */ return SQL_SUCCESS; } *************** *** 1342,1347 **** --- 1386,1418 ---- } result = SQL_SUCCESS; + #ifdef KANJI + { + char *kanji; + + kanji = euc_to_sjis(stmt->cursor_name, SQL_NTS); + if ( ! kanji) { + stmt->errornumber = STMT_NO_MEMORY_ERROR; + stmt->errormsg = "No memory available to convert kanji code"; + SC_log_error(func, "", stmt); + return SQL_ERROR; + } + + len = strlen(kanji); + + if (szCursor) { + strncpy_null(szCursor, kanji, cbCursorMax); + + if (len >= cbCursorMax) { + result = SQL_SUCCESS_WITH_INFO; + stmt->errornumber = STMT_TRUNCATED; + stmt->errormsg = "The buffer was too small for the result."; + } + } + + free(kanji); + } + #else /* KANJI */ len = strlen(stmt->cursor_name); if (szCursor) *************** *** 1355,1360 **** --- 1426,1432 ---- stmt->errormsg = "The buffer was too small for the GetCursorName."; } } + #endif /* KANJI */ if (pcbCursor) *pcbCursor = len; Index: psqlodbc/win32.mak diff -c psqlodbc/win32.mak:1.1.1.3 psqlodbc/win32.mak:1.1.1.3.4.1 *** psqlodbc/win32.mak:1.1.1.3 Tue May 8 19:19:55 2001 --- psqlodbc/win32.mak Fri Jul 13 23:05:14 2001 *************** *** 4,12 **** # # Description: psqlodbc Makefile for Win32. # ! # Configurations: Debug, Release, MultibyteDebug, MultibyteRelease # Build Types: ALL, CLEAN ! # Usage: NMAKE /f win32.mak CFG=[Release | Debug | MultibyteRelease | MultiByteDebug] [ALL | CLEAN] # # Comments: Created by Dave Page, 2001-02-12 # --- 4,12 ---- # # Description: psqlodbc Makefile for Win32. # ! # Configurations: Debug, Release, MultibyteDebug, MultibyteRelease, KanjiDebug, KanjiRelease # Build Types: ALL, CLEAN ! # Usage: NMAKE /f win32.mak CFG=[Release | Debug | MultibyteRelease | MultibyteDebug | KanjiRelease | KanjiDebug] [ALL | CLEAN] # # Comments: Created by Dave Page, 2001-02-12 # *************** *** 19,30 **** !MESSAGE !ENDIF ! !IF "$(CFG)" != "Release" && "$(CFG)" != "Debug" && "$(CFG)" != "MultibyteRelease" && "$(CFG)" != "MultibyteDebug" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE ! !MESSAGE NMAKE /f win32.mak CFG=[Release | Debug | MultibyteRelease | MultiByteDebug] [ALL | CLEAN] !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE --- 19,30 ---- !MESSAGE !ENDIF ! !IF "$(CFG)" != "Release" && "$(CFG)" != "Debug" && "$(CFG)" != "MultibyteRelease" && "$(CFG)" != "MultibyteDebug" && "$(CFG)" != "KanjiRelease" && "$(CFG)" != "KanjiDebug" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE ! !MESSAGE NMAKE /f win32.mak CFG=[Release | Debug | MultibyteRelease | MultibyteDebug | KanjiRelease | KanjiDebug] [ALL | CLEAN] !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE *************** *** 32,37 **** --- 32,39 ---- !MESSAGE "Debug" (Win32 Debug DLL) !MESSAGE "MultibyteRelease" (Win32 Release DLL with Multibyte support) !MESSAGE "MultibyteDebug" (Win32 Release DLL with Multibyte support) + !MESSAGE "KanjiRelease" (Win32 Release DLL with Kanji support) + !MESSAGE "KanjiDebug" (Win32 Release DLL with Kanji support) !MESSAGE !ERROR An invalid configuration was specified. !ENDIF *************** *** 42,52 **** NULL=nul !ENDIF ! !IF "$(CFG)" == "Release" || "$(CFG)" == "MultibyteRelease" !IF "$(CFG)" == "MultibyteRelease" OUTDIR=.\MultibyteRelease INTDIR=.\MultibyteRelease !ELSE OUTDIR=.\Release INTDIR=.\Release --- 44,57 ---- NULL=nul !ENDIF ! !IF "$(CFG)" == "Release" || "$(CFG)" == "MultibyteRelease" || "$(CFG)" == "KanjiRelease" !IF "$(CFG)" == "MultibyteRelease" OUTDIR=.\MultibyteRelease INTDIR=.\MultibyteRelease + !ELSE IF "$(CFG)" == "KanjiRelease" + OUTDIR=.\KanjiRelease + INTDIR=.\KanjiRelease !ELSE OUTDIR=.\Release INTDIR=.\Release *************** *** 66,71 **** --- 71,79 ---- -@erase "$(INTDIR)\execute.obj" -@erase "$(INTDIR)\gpps.obj" -@erase "$(INTDIR)\info.obj" + !IF "$(CFG)" == "KanjiRelease" + -@erase "$(INTDIR)\kanji.obj" + !ENDIF -@erase "$(INTDIR)\lobj.obj" -@erase "$(INTDIR)\misc.obj" !IF "$(CFG)" == "MultibyteRelease" *************** *** 94,99 **** --- 102,109 ---- CPP=cl.exe !IF "$(CFG)" == "MultibyteRelease" CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /D "MULTIBYTE" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c + !ELSE IF "$(CFG)" == "KanjiRelease" + CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /D "KANJI" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c !ELSE CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c !ENDIF *************** *** 150,155 **** --- 160,168 ---- "$(INTDIR)\execute.obj" \ "$(INTDIR)\gpps.obj" \ "$(INTDIR)\info.obj" \ + !IF "$(CFG)" == "KanjiRelease" + "$(INTDIR)\kanji.obj" \ + !ENDIF "$(INTDIR)\lobj.obj" \ "$(INTDIR)\misc.obj" \ !IF "$(CFG)" == "MultibyteRelease" *************** *** 178,183 **** --- 191,199 ---- !IF "$(CFG)" == "MultibyteDebug" OUTDIR=.\MultibyteDebug INTDIR=.\MultibyteDebug + !ELSE IF "$(CFG)" == "KanjiDebug" + OUTDIR=.\KanjiDebug + INTDIR=.\KanjiDebug !ELSE OUTDIR=.\Debug INTDIR=.\Debug *************** *** 197,202 **** --- 213,221 ---- -@erase "$(INTDIR)\execute.obj" -@erase "$(INTDIR)\gpps.obj" -@erase "$(INTDIR)\info.obj" + !IF "$(CFG)" == "KanjiDebug" + -@erase "$(INTDIR)\kanji.obj" + !ENDIF -@erase "$(INTDIR)\lobj.obj" -@erase "$(INTDIR)\misc.obj" !IF "$(CFG)" == "MultibyteDebug" *************** *** 228,233 **** --- 247,254 ---- CPP=cl.exe !IF "$(CFG)" == "MultibyteDebug" CPP_PROJ=/nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /D "MULTIBYTE" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /GZ /c + !ELSE IF "$(CFG)" == "KanjiDebug" + CPP_PROJ=/nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /D "KANJI" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /GZ /c !ELSE CPP_PROJ=/nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PSQLODBC_EXPORTS" /Fp"$(INTDIR)\psqlodbc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /GZ /c !ENDIF *************** *** 284,289 **** --- 305,313 ---- "$(INTDIR)\execute.obj" \ "$(INTDIR)\gpps.obj" \ "$(INTDIR)\info.obj" \ + !IF "$(CFG)" == "KanjiDebug" + "$(INTDIR)\kanji.obj" \ + !ENDIF "$(INTDIR)\lobj.obj" \ "$(INTDIR)\misc.obj" \ !IF "$(CFG)" == "MultibyteDebug" *************** *** 309,315 **** !ENDIF ! !IF "$(CFG)" == "Release" || "$(CFG)" == "Debug" || "$(CFG)" == "MultibyteRelease" || "$(CFG)" == "MultibyteDebug" SOURCE=bind.c --- 333,339 ---- !ENDIF ! !IF "$(CFG)" == "Release" || "$(CFG)" == "Debug" || "$(CFG)" == "MultibyteRelease" || "$(CFG)" == "MultibyteDebug" || "$(CFG)" == "KanjiRelease" || "$(CFG)" == "KanjiDebug" SOURCE=bind.c *************** *** 371,376 **** --- 395,410 ---- $(CPP) $(CPP_PROJ) $(SOURCE) + !IF "$(CFG)" == "KanjiRelease" || "$(CFG)" == "KanjiDebug" + + SOURCE=kanji.c + + "$(INTDIR)\kanji.obj" : $(SOURCE) "$(INTDIR)" + $(CPP) $(CPP_PROJ) $(SOURCE) + + !ENDIF + + SOURCE=lobj.c "$(INTDIR)\lobj.obj" : $(SOURCE) "$(INTDIR)" *************** *** 429,434 **** --- 463,473 ---- $(RSC) /l 0x809 /fo"$(INTDIR)\psqlodbc.res" /d "NDEBUG" /d "MULTIBYTE" $(SOURCE) !ENDIF + !IF "$(CFG)" == "KanjiRelease" + "$(INTDIR)\psqlodbc.res" : $(SOURCE) "$(INTDIR)" + $(RSC) /l 0x809 /fo"$(INTDIR)\psqlodbc.res" /d "NDEBUG" /d "KANJI" $(SOURCE) + !ENDIF + !IF "$(CFG)" == "Debug" "$(INTDIR)\psqlodbc.res" : $(SOURCE) "$(INTDIR)" $(RSC) /l 0x809 /fo"$(INTDIR)\psqlodbc.res" /d "_DEBUG" $(SOURCE) *************** *** 437,442 **** --- 476,486 ---- !IF "$(CFG)" == "MultibyteDebug" "$(INTDIR)\psqlodbc.res" : $(SOURCE) "$(INTDIR)" $(RSC) /l 0x809 /fo"$(INTDIR)\psqlodbc.res" /d "_DEBUG" /d "MULTIBYTE" $(SOURCE) + !ENDIF + + !IF "$(CFG)" == "KanjiDebug" + "$(INTDIR)\psqlodbc.res" : $(SOURCE) "$(INTDIR)" + $(RSC) /l 0x809 /fo"$(INTDIR)\psqlodbc.res" /d "_DEBUG" /d "KANJI" $(SOURCE) !ENDIF