projects / chise / xemacs-chise.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add some missing mappings to CHINA3-JEF code points.
[chise/xemacs-chise.git] / src / mule-charset.c
diff --git a/src/mule-charset.c b/src/mule-charset.c
index ae25638..2031052 100644 (file)
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -1,7 +1,7 @@
 /* Functions to handle multilingual characters.
    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.
 /* Functions to handle multilingual characters.
    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.
-   Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
+   Copyright (C) 1999,2000,2001,2002 MORIOKA Tomohiko
 
 This file is part of XEmacs.
 
 
 This file is part of XEmacs.
 
@@ -66,15 +66,33 @@ Lisp_Object Vcharset_chinese_cns11643_2;
 #ifdef UTF2000
 Lisp_Object Vcharset_ucs;
 Lisp_Object Vcharset_ucs_bmp;
 #ifdef UTF2000
 Lisp_Object Vcharset_ucs;
 Lisp_Object Vcharset_ucs_bmp;
+Lisp_Object Vcharset_ucs_smp;
+Lisp_Object Vcharset_ucs_sip;
 Lisp_Object Vcharset_ucs_cns;
 Lisp_Object Vcharset_ucs_jis;
 Lisp_Object Vcharset_ucs_cns;
 Lisp_Object Vcharset_ucs_jis;
+Lisp_Object Vcharset_ucs_ks;
 Lisp_Object Vcharset_ucs_big5;
 Lisp_Object Vcharset_latin_viscii;
 Lisp_Object Vcharset_latin_tcvn5712;
 Lisp_Object Vcharset_latin_viscii_lower;
 Lisp_Object Vcharset_latin_viscii_upper;
 Lisp_Object Vcharset_ucs_big5;
 Lisp_Object Vcharset_latin_viscii;
 Lisp_Object Vcharset_latin_tcvn5712;
 Lisp_Object Vcharset_latin_viscii_lower;
 Lisp_Object Vcharset_latin_viscii_upper;
+Lisp_Object Vcharset_jis_x0208;
 Lisp_Object Vcharset_chinese_big5;
 Lisp_Object Vcharset_chinese_big5;
-Lisp_Object Vcharset_chinese_big5_cdp;
+/* Lisp_Object Vcharset_chinese_big5_cdp; */
+Lisp_Object Vcharset_ideograph_hanziku_1;
+Lisp_Object Vcharset_ideograph_hanziku_2;
+Lisp_Object Vcharset_ideograph_hanziku_3;
+Lisp_Object Vcharset_ideograph_hanziku_4;
+Lisp_Object Vcharset_ideograph_hanziku_5;
+Lisp_Object Vcharset_ideograph_hanziku_6;
+Lisp_Object Vcharset_ideograph_hanziku_7;
+Lisp_Object Vcharset_ideograph_hanziku_8;
+Lisp_Object Vcharset_ideograph_hanziku_9;
+Lisp_Object Vcharset_ideograph_hanziku_10;
+Lisp_Object Vcharset_ideograph_hanziku_11;
+Lisp_Object Vcharset_ideograph_hanziku_12;
+Lisp_Object Vcharset_china3_jef;
+Lisp_Object Vcharset_ideograph_cbeta;
 Lisp_Object Vcharset_ideograph_gt;
 Lisp_Object Vcharset_ideograph_gt_pj_1;
 Lisp_Object Vcharset_ideograph_gt_pj_2;
 Lisp_Object Vcharset_ideograph_gt;
 Lisp_Object Vcharset_ideograph_gt_pj_1;
 Lisp_Object Vcharset_ideograph_gt_pj_2;
@@ -87,30 +105,8 @@ Lisp_Object Vcharset_ideograph_gt_pj_8;
 Lisp_Object Vcharset_ideograph_gt_pj_9;
 Lisp_Object Vcharset_ideograph_gt_pj_10;
 Lisp_Object Vcharset_ideograph_gt_pj_11;
 Lisp_Object Vcharset_ideograph_gt_pj_9;
 Lisp_Object Vcharset_ideograph_gt_pj_10;
 Lisp_Object Vcharset_ideograph_gt_pj_11;
+Lisp_Object Vcharset_ideograph_daikanwa_2;
 Lisp_Object Vcharset_ideograph_daikanwa;
 Lisp_Object Vcharset_ideograph_daikanwa;
-Lisp_Object Vcharset_mojikyo;
-Lisp_Object Vcharset_mojikyo_2022_1;
-Lisp_Object Vcharset_mojikyo_pj_1;
-Lisp_Object Vcharset_mojikyo_pj_2;
-Lisp_Object Vcharset_mojikyo_pj_3;
-Lisp_Object Vcharset_mojikyo_pj_4;
-Lisp_Object Vcharset_mojikyo_pj_5;
-Lisp_Object Vcharset_mojikyo_pj_6;
-Lisp_Object Vcharset_mojikyo_pj_7;
-Lisp_Object Vcharset_mojikyo_pj_8;
-Lisp_Object Vcharset_mojikyo_pj_9;
-Lisp_Object Vcharset_mojikyo_pj_10;
-Lisp_Object Vcharset_mojikyo_pj_11;
-Lisp_Object Vcharset_mojikyo_pj_12;
-Lisp_Object Vcharset_mojikyo_pj_13;
-Lisp_Object Vcharset_mojikyo_pj_14;
-Lisp_Object Vcharset_mojikyo_pj_15;
-Lisp_Object Vcharset_mojikyo_pj_16;
-Lisp_Object Vcharset_mojikyo_pj_17;
-Lisp_Object Vcharset_mojikyo_pj_18;
-Lisp_Object Vcharset_mojikyo_pj_19;
-Lisp_Object Vcharset_mojikyo_pj_20;
-Lisp_Object Vcharset_mojikyo_pj_21;
 Lisp_Object Vcharset_ethiopic_ucs;
 #endif
 Lisp_Object Vcharset_chinese_big5_1;
 Lisp_Object Vcharset_ethiopic_ucs;
 #endif
 Lisp_Object Vcharset_chinese_big5_1;
@@ -181,20 +177,6 @@ const Bytecount rep_bytes_by_first_byte[0xA0] =
 
 #ifdef UTF2000
 
 
 #ifdef UTF2000
 
-INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs);
-INLINE_HEADER int
-CHARSET_BYTE_SIZE (Lisp_Charset* cs)
-{
-  /* ad-hoc method for `ascii' */
-  if ((CHARSET_CHARS (cs) == 94) &&
-      (CHARSET_BYTE_OFFSET (cs) != 33))
-    return 128 - CHARSET_BYTE_OFFSET (cs);
-  else
-    return CHARSET_CHARS (cs);
-}
-
-#define XCHARSET_BYTE_SIZE(ccs)        CHARSET_BYTE_SIZE (XCHARSET (ccs))
-
 int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
 int
 decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
 int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
 int
 decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
@@ -223,71 +205,15 @@ decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
   return 0;
 }
 
   return 0;
 }
 
-INLINE_HEADER void
-decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
-                           int code_point);
-INLINE_HEADER void
-decoding_table_remove_char (Lisp_Object v, int dim, int byte_offset,
-                           int code_point)
-{
-  int i = -1;
-
-  while (dim > 0)
-    {
-      Lisp_Object nv;
-
-      dim--;
-      i = ((code_point >> (8 * dim)) & 255) - byte_offset;
-      nv = XVECTOR_DATA(v)[i];
-      if (!VECTORP (nv))
-       break;
-      v = nv;
-    }
-  if (i >= 0)
-    XVECTOR_DATA(v)[i] = Qnil;
-}
-
-INLINE_HEADER void
-decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
-                        int code_point, Lisp_Object character);
-INLINE_HEADER void
-decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
-                        int code_point, Lisp_Object character)
-{
-  int i = -1;
-  Lisp_Object nv;
-  int ccs_len = XVECTOR_LENGTH (v);
-
-  while (dim > 0)
-    {
-      dim--;
-      i = ((code_point >> (8 * dim)) & 255) - byte_offset;
-      nv = XVECTOR_DATA(v)[i];
-      if (dim > 0)
-       {
-         if (!VECTORP (nv))
-           nv = (XVECTOR_DATA(v)[i] = make_older_vector (ccs_len, Qnil));
-         v = nv;
-       }
-      else
-       break;
-    }
-  XVECTOR_DATA(v)[i] = character;
-}
-
 Lisp_Object
 put_char_ccs_code_point (Lisp_Object character,
                         Lisp_Object ccs, Lisp_Object value)
 {
 Lisp_Object
 put_char_ccs_code_point (Lisp_Object character,
                         Lisp_Object ccs, Lisp_Object value)
 {
-  Lisp_Object encoding_table;
-
   if (!EQ (XCHARSET_NAME (ccs), Qucs)
   if (!EQ (XCHARSET_NAME (ccs), Qucs)
+      || !INTP (value)
       || (XCHAR (character) != XINT (value)))
     {
       Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
       || (XCHAR (character) != XINT (value)))
     {
       Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
-      int dim = XCHARSET_DIMENSION (ccs);
-      int ccs_len = XCHARSET_BYTE_SIZE (ccs);
-      int byte_offset = XCHARSET_BYTE_OFFSET (ccs);
       int code_point;
 
       if (CONSP (value))
       int code_point;
 
       if (CONSP (value))
@@ -335,26 +261,14 @@ put_char_ccs_code_point (Lisp_Object character,
       if (VECTORP (v))
        {
          Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
       if (VECTORP (v))
        {
          Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
-         if (!NILP (cpos))
+         if (INTP (cpos))
            {
            {
-             decoding_table_remove_char (v, dim, byte_offset, XINT (cpos));
+             decoding_table_remove_char (ccs, XINT (cpos));
            }
        }
            }
        }
-      else
-       {
-         XCHARSET_DECODING_TABLE (ccs)
-           = v = make_older_vector (ccs_len, Qnil);
-       }
-
-      decoding_table_put_char (v, dim, byte_offset, code_point, character);
+      decoding_table_put_char (ccs, code_point, character);
     }
     }
-  if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
-    {
-      XCHARSET_ENCODING_TABLE (ccs)
-       = encoding_table = make_char_id_table (Qnil);
-    }
-  put_char_id_table (XCHAR (character), value, encoding_table);
-  return Qt;
+  return value;
 }
 
 Lisp_Object
 }
 
 Lisp_Object
@@ -369,15 +283,12 @@ remove_char_ccs (Lisp_Object character, Lisp_Object ccs)
 
       if (!NILP (cpos))
        {
 
       if (!NILP (cpos))
        {
-         decoding_table_remove_char (decoding_table,
-                                     XCHARSET_DIMENSION (ccs),
-                                     XCHARSET_BYTE_OFFSET (ccs),
-                                     XINT (cpos));
+         decoding_table_remove_char (ccs, XINT (cpos));
        }
     }
        }
     }
-  if (CHAR_ID_TABLE_P (encoding_table))
+  if (CHAR_TABLEP (encoding_table))
     {
     {
-      put_char_id_table (XCHAR (character), Qnil, encoding_table);
+      put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound);
     }
   return Qt;
 }
     }
   return Qt;
 }
@@ -396,6 +307,10 @@ Lisp_Object Qdirection;
 Lisp_Object Qreverse_direction_charset;
 Lisp_Object Qleading_byte;
 Lisp_Object Qshort_name, Qlong_name;
 Lisp_Object Qreverse_direction_charset;
 Lisp_Object Qleading_byte;
 Lisp_Object Qshort_name, Qlong_name;
+#ifdef UTF2000
+Lisp_Object Qmin_code, Qmax_code, Qcode_offset;
+Lisp_Object Qmother, Qconversion, Q94x60, Q94x94x60;
+#endif
 
 Lisp_Object Qascii,
   Qcontrol_1,
 
 Lisp_Object Qascii,
   Qcontrol_1,
@@ -423,8 +338,11 @@ Lisp_Object Qascii,
 #ifdef UTF2000
   Qucs,
   Qucs_bmp,
 #ifdef UTF2000
   Qucs,
   Qucs_bmp,
+  Qucs_smp,
+  Qucs_sip,
   Qucs_cns,
   Qucs_jis,
   Qucs_cns,
   Qucs_jis,
+  Qucs_ks,
   Qucs_big5,
   Qlatin_viscii,
   Qlatin_tcvn5712,
   Qucs_big5,
   Qlatin_viscii,
   Qlatin_tcvn5712,
@@ -432,8 +350,24 @@ Lisp_Object Qascii,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
+  Qjis_x0208,
   Qchinese_big5,
   Qchinese_big5,
-  Qchinese_big5_cdp,
+  /*  Qchinese_big5_cdp, */
+  Qideograph_hanziku_1,
+  Qideograph_hanziku_2,
+  Qideograph_hanziku_3,
+  Qideograph_hanziku_4,
+  Qideograph_hanziku_5,
+  Qideograph_hanziku_6,
+  Qideograph_hanziku_7,
+  Qideograph_hanziku_8,
+  Qideograph_hanziku_9,
+  Qideograph_hanziku_10,
+  Qideograph_hanziku_11,
+  Qideograph_hanziku_12,
+  Qchina3_jef,
+  Qideograph_cbeta,
+  Qideograph_daikanwa_2,
   Qideograph_daikanwa,
   Qideograph_gt,
   Qideograph_gt_pj_1,
   Qideograph_daikanwa,
   Qideograph_gt,
   Qideograph_gt_pj_1,
@@ -447,29 +381,6 @@ Lisp_Object Qascii,
   Qideograph_gt_pj_9,
   Qideograph_gt_pj_10,
   Qideograph_gt_pj_11,
   Qideograph_gt_pj_9,
   Qideograph_gt_pj_10,
   Qideograph_gt_pj_11,
-  Qmojikyo,
-  Qmojikyo_2022_1,
-  Qmojikyo_pj_1,
-  Qmojikyo_pj_2,
-  Qmojikyo_pj_3,
-  Qmojikyo_pj_4,
-  Qmojikyo_pj_5,
-  Qmojikyo_pj_6,
-  Qmojikyo_pj_7,
-  Qmojikyo_pj_8,
-  Qmojikyo_pj_9,
-  Qmojikyo_pj_10,
-  Qmojikyo_pj_11,
-  Qmojikyo_pj_12,
-  Qmojikyo_pj_13,
-  Qmojikyo_pj_14,
-  Qmojikyo_pj_15,
-  Qmojikyo_pj_16,
-  Qmojikyo_pj_17,
-  Qmojikyo_pj_18,
-  Qmojikyo_pj_19,
-  Qmojikyo_pj_20,
-  Qmojikyo_pj_21,
   Qethiopic_ucs,
 #endif
   Qchinese_big5_1,
   Qethiopic_ucs,
 #endif
   Qchinese_big5_1,
@@ -814,8 +725,8 @@ mark_charset (Lisp_Object obj)
   mark_object (cs->registry);
   mark_object (cs->ccl_program);
 #ifdef UTF2000
   mark_object (cs->registry);
   mark_object (cs->ccl_program);
 #ifdef UTF2000
-  mark_object (cs->encoding_table);
-  /* mark_object (cs->decoding_table); */
+  mark_object (cs->decoding_table);
+  mark_object (cs->mother);
 #endif
   return cs->name;
 }
 #endif
   return cs->name;
 }
@@ -862,7 +773,7 @@ static const struct lrecord_description charset_description[] = {
   { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
 #ifdef UTF2000
   { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
   { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
 #ifdef UTF2000
   { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
-  { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, mother) },
 #endif
   { XD_END }
 };
 #endif
   { XD_END }
 };
@@ -882,8 +793,9 @@ make_charset (Charset_ID id, Lisp_Object name,
              Lisp_Object long_name, Lisp_Object doc,
              Lisp_Object reg,
              Lisp_Object decoding_table,
              Lisp_Object long_name, Lisp_Object doc,
              Lisp_Object reg,
              Lisp_Object decoding_table,
-             Emchar ucs_min, Emchar ucs_max,
-             Emchar code_offset, unsigned char byte_offset)
+             Emchar min_code, Emchar max_code,
+             Emchar code_offset, unsigned char byte_offset,
+             Lisp_Object mother, unsigned char conversion)
 {
   Lisp_Object obj;
   Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
 {
   Lisp_Object obj;
   Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
@@ -907,12 +819,13 @@ make_charset (Charset_ID id, Lisp_Object name,
   CHARSET_CCL_PROGRAM  (cs) = Qnil;
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
 #ifdef UTF2000
   CHARSET_CCL_PROGRAM  (cs) = Qnil;
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
 #ifdef UTF2000
-  CHARSET_DECODING_TABLE(cs) = Qnil;
-  CHARSET_ENCODING_TABLE(cs) = Qnil;
-  CHARSET_UCS_MIN(cs) = ucs_min;
-  CHARSET_UCS_MAX(cs) = ucs_max;
-  CHARSET_CODE_OFFSET(cs) = code_offset;
-  CHARSET_BYTE_OFFSET(cs) = byte_offset;
+  CHARSET_DECODING_TABLE(cs) = Qunbound;
+  CHARSET_MIN_CODE     (cs) = min_code;
+  CHARSET_MAX_CODE     (cs) = max_code;
+  CHARSET_CODE_OFFSET  (cs) = code_offset;
+  CHARSET_BYTE_OFFSET  (cs) = byte_offset;
+  CHARSET_MOTHER       (cs) = mother;
+  CHARSET_CONVERSION   (cs) = conversion;
 #endif
 
 #ifndef UTF2000
 #endif
 
 #ifndef UTF2000
@@ -995,37 +908,102 @@ get_unallocated_leading_byte (int dimension)
 #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
 
 Emchar
 #define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
 
 Emchar
+decode_defined_char (Lisp_Object ccs, int code_point)
+{
+  int dim = XCHARSET_DIMENSION (ccs);
+  Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
+  Emchar char_id = -1;
+  Lisp_Object mother;
+
+  while (dim > 0)
+    {
+      dim--;
+      decoding_table
+       = get_ccs_octet_table (decoding_table, ccs,
+                              (code_point >> (dim * 8)) & 255);
+    }
+  if (CHARP (decoding_table))
+    return XCHAR (decoding_table);
+  if (char_id >= 0)
+    return char_id;
+  else if ( CHARSETP (mother = XCHARSET_MOTHER (ccs)) )
+    {
+      if ( XCHARSET_CONVERSION (ccs) == CONVERSION_IDENTICAL )
+       {
+         if ( EQ (mother, Vcharset_ucs) )
+           return DECODE_CHAR (mother, code_point);
+         else
+           return decode_defined_char (mother, code_point);
+       }
+    }
+  return -1;
+}
+
+Emchar
 decode_builtin_char (Lisp_Object charset, int code_point)
 {
 decode_builtin_char (Lisp_Object charset, int code_point)
 {
+  Lisp_Object mother = XCHARSET_MOTHER (charset);
   int final;
 
   int final;
 
-  if (EQ (charset, Vcharset_chinese_big5))
+  if ( CHARSETP (mother) && (XCHARSET_MAX_CODE (charset) > 0) )
     {
     {
-      int c1 = code_point >> 8;
-      int c2 = code_point & 0xFF;
-      unsigned int I;
-
-      if ( (  (0xA1 <= c1) && (c1 <= 0xFE)  )
-          &&
-          ( ((0x40 <= c2) && (c2 <= 0x7E)) ||
-            ((0xA1 <= c2) && (c2 <= 0xFE)) ) )
+      int code = code_point;
+
+      if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
        {
        {
-         I = (c1 - 0xA1) * BIG5_SAME_ROW
-           + c2 - (c2 < 0x7F ? 0x40 : 0x62);
+         int row = code_point >> 8;
+         int cell = code_point & 255;    
 
 
-         if (c1 < 0xC9)
-           {
-             charset = Vcharset_chinese_big5_1;
-           }
-         else
-           {
-             charset = Vcharset_chinese_big5_2;
-             I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
-           }
-         code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
+         if (row < 16 + 32)
+           return -1;
+         else if (row < 16 + 32 + 30)
+           code = (row - (16 + 32)) * 94 + cell - 33;
+         else if (row < 18 + 32 + 30)
+           return -1;
+         else if (row < 18 + 32 + 60)
+           code = (row - (18 + 32)) * 94 + cell - 33;
+       }
+      else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
+       {
+         int plane = code_point >> 16;
+         int row = (code_point >> 8) & 255;
+         int cell = code_point & 255;    
+
+         if (row < 16 + 32)
+           return -1;
+         else if (row < 16 + 32 + 30)
+           code
+             = (plane - 33) * 94 * 60
+             + (row - (16 + 32)) * 94
+             + cell - 33;
+         else if (row < 18 + 32 + 30)
+           return -1;
+         else if (row < 18 + 32 + 60)
+           code
+             = (plane - 33) * 94 * 60
+             + (row - (18 + 32)) * 94
+             + cell - 33;
        }
        }
+      return
+       decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset));
     }
     }
-  if ((final = XCHARSET_FINAL (charset)) >= '0')
+  if (XCHARSET_MAX_CODE (charset))
+    {
+      Emchar cid
+       = (XCHARSET_DIMENSION (charset) == 1
+          ?
+          code_point - XCHARSET_BYTE_OFFSET (charset)
+          :
+          ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
+          * XCHARSET_CHARS (charset)
+          + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset))
+       + XCHARSET_CODE_OFFSET (charset);
+      if ((cid < XCHARSET_MIN_CODE (charset))
+         || (XCHARSET_MAX_CODE (charset) < cid))
+       return -1;
+      return cid;
+    }
+  else if ((final = XCHARSET_FINAL (charset)) >= '0')
     {
       if (XCHARSET_DIMENSION (charset) == 1)
        {
     {
       if (XCHARSET_DIMENSION (charset) == 1)
        {
@@ -1062,122 +1040,156 @@ decode_builtin_char (Lisp_Object charset, int code_point)
            }
        }
     }
            }
        }
     }
-  else if (XCHARSET_UCS_MAX (charset))
-    {
-      Emchar cid
-       = (XCHARSET_DIMENSION (charset) == 1
-          ?
-          code_point - XCHARSET_BYTE_OFFSET (charset)
-          :
-          ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
-          * XCHARSET_CHARS (charset)
-          + (code_point & 0xFF) - XCHARSET_BYTE_OFFSET (charset))
-       - XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset);
-      if ((cid < XCHARSET_UCS_MIN (charset))
-         || (XCHARSET_UCS_MAX (charset) < cid))
-       return -1;
-      return cid;
-    }
   else
     return -1;
 }
 
 int
   else
     return -1;
 }
 
 int
-range_charset_code_point (Lisp_Object charset, Emchar ch)
+charset_code_point (Lisp_Object charset, Emchar ch, int defined_only)
 {
 {
-  int d;
+  Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (charset);
+  Lisp_Object ret;
 
 
-  if ((XCHARSET_UCS_MIN (charset) <= ch)
-      && (ch <= XCHARSET_UCS_MAX (charset)))
-    {
-      d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset);
-
-      if (XCHARSET_CHARS (charset) == 256)
-       return d;
-      else if (XCHARSET_DIMENSION (charset) == 1)
-       return d + XCHARSET_BYTE_OFFSET (charset);
-      else if (XCHARSET_DIMENSION (charset) == 2)
-       return
-         ((d / XCHARSET_CHARS (charset)
-           + XCHARSET_BYTE_OFFSET (charset)) << 8)
-         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
-      else if (XCHARSET_DIMENSION (charset) == 3)
-       return
-         ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
-           + XCHARSET_BYTE_OFFSET (charset)) << 16)
-         | ((d / XCHARSET_CHARS (charset)
-             % XCHARSET_CHARS (charset)
-             + XCHARSET_BYTE_OFFSET (charset)) << 8)
-         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
-      else /* if (XCHARSET_DIMENSION (charset) == 4) */
-       return
-         ((d / (XCHARSET_CHARS (charset)
-                * XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
-           + XCHARSET_BYTE_OFFSET (charset)) << 24)
-         | ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
-             % XCHARSET_CHARS (charset)
-             + XCHARSET_BYTE_OFFSET (charset)) << 16)
-         | ((d / XCHARSET_CHARS (charset) % XCHARSET_CHARS (charset)
-             + XCHARSET_BYTE_OFFSET (charset)) << 8)
-         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
-    }
-  else if (XCHARSET_CODE_OFFSET (charset) == 0)
+  if ( CHAR_TABLEP (encoding_table)
+       && INTP (ret = get_char_id_table (XCHAR_TABLE(encoding_table),
+                                        ch)) )
+    return XINT (ret);
+  else
     {
     {
-      if (XCHARSET_DIMENSION (charset) == 1)
+      Lisp_Object mother = XCHARSET_MOTHER (charset);
+      int min = XCHARSET_MIN_CODE (charset);
+      int max = XCHARSET_MAX_CODE (charset);
+      int code;
+
+      if ( CHARSETP (mother) )
+       code = charset_code_point (mother, ch, defined_only);
+      else if (defined_only)
+       return -1;
+      else
+       code = ch;
+      if ( ((max == 0) && CHARSETP (mother)) ||
+          ((min <= code) && (code <= max)) )
        {
        {
-         if (XCHARSET_CHARS (charset) == 94)
+         int d = code - XCHARSET_CODE_OFFSET (charset);
+
+         if ( XCHARSET_CONVERSION (charset) == CONVERSION_IDENTICAL )
+           return d;
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94 )
+           return d + 33;
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96 )
+           return d + 32;
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x60 )
            {
            {
-             if (((d = ch - (MIN_CHAR_94
-                             + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0)
-                 && (d < 94))
-               return d + 33;
+             int row  = d / 94;
+             int cell = d % 94 + 33;
+
+             if (row < 30)
+               row += 16 + 32;
+             else
+               row += 18 + 32;
+             return (row << 8) | cell;
            }
            }
-         else if (XCHARSET_CHARS (charset) == 96)
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94 )
+           return ((d / 94 + 33) << 8) | (d % 94 + 33);
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96 )
+           return ((d / 96 + 32) << 8) | (d % 96 + 32);
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x60 )
            {
            {
-             if (((d = ch - (MIN_CHAR_96
-                             + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0)
-                 && (d < 96))
-               return d + 32;
+             int plane =  d / (94 * 60) + 33;
+             int row   = (d % (94 * 60)) / 94;
+             int cell  =  d %  94 + 33;
+
+             if (row < 30)
+               row += 16 + 32;
+             else
+               row += 18 + 32;
+             return (plane << 16) | (row << 8) | cell;
            }
            }
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94 )
+           return
+             (   (d / (94 * 94) + 33) << 16)
+             |  ((d / 94 % 94   + 33) <<  8)
+             |   (d % 94        + 33);
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96 )
+           return
+             (   (d / (96 * 96) + 32) << 16)
+             |  ((d / 96 % 96   + 32) <<  8)
+             |   (d % 96        + 32);
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_94x94x94x94 )
+           return
+             (  (d / (94 * 94 * 94) + 33) << 24)
+             | ((d / (94 * 94) % 94 + 33) << 16)
+             | ((d / 94 % 94        + 33) <<  8)
+             |  (d % 94             + 33);
+         else if ( XCHARSET_CONVERSION (charset) == CONVERSION_96x96x96x96 )
+           return
+             (  (d / (96 * 96 * 96) + 32) << 24)
+             | ((d / (96 * 96) % 96 + 32) << 16)
+             | ((d / 96 % 96        + 32) <<  8)
+             |  (d % 96             + 32);
          else
          else
-           return -1;
+           {
+             printf ("Unknown CCS-conversion %d is specified!",
+                     XCHARSET_CONVERSION (charset));
+             exit (-1);
+           }
        }
        }
-      else if (XCHARSET_DIMENSION (charset) == 2)
+      else if ( ( XCHARSET_FINAL (charset) >= '0' ) &&
+               ( XCHARSET_MIN_CODE (charset) == 0 )
+              /*
+               (XCHARSET_CODE_OFFSET (charset) == 0) ||
+               (XCHARSET_CODE_OFFSET (charset)
+                == XCHARSET_MIN_CODE (charset))
+              */ )
        {
        {
-         if (XCHARSET_CHARS (charset) == 94)
+         int d;
+
+         if (XCHARSET_DIMENSION (charset) == 1)
            {
            {
-             if (((d = ch - (MIN_CHAR_94x94
-                             + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
-                  >= 0)
-                 && (d < 94 * 94))
-               return (((d / 94) + 33) << 8) | (d % 94 + 33);
+             if (XCHARSET_CHARS (charset) == 94)
+               {
+                 if (((d = ch - (MIN_CHAR_94
+                                 + (XCHARSET_FINAL (charset) - '0') * 94))
+                      >= 0)
+                     && (d < 94))
+                   return d + 33;
+               }
+             else if (XCHARSET_CHARS (charset) == 96)
+               {
+                 if (((d = ch - (MIN_CHAR_96
+                                 + (XCHARSET_FINAL (charset) - '0') * 96))
+                      >= 0)
+                     && (d < 96))
+                   return d + 32;
+               }
+             else
+               return -1;
            }
            }
-         else if (XCHARSET_CHARS (charset) == 96)
+         else if (XCHARSET_DIMENSION (charset) == 2)
            {
            {
-             if (((d = ch - (MIN_CHAR_96x96
-                             + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
-                  >= 0)
-                 && (d < 96 * 96))
-               return (((d / 96) + 32) << 8) | (d % 96 + 32);
+             if (XCHARSET_CHARS (charset) == 94)
+               {
+                 if (((d = ch - (MIN_CHAR_94x94
+                                 +
+                                 (XCHARSET_FINAL (charset) - '0') * 94 * 94))
+                      >= 0)
+                     && (d < 94 * 94))
+                   return (((d / 94) + 33) << 8) | (d % 94 + 33);
+               }
+             else if (XCHARSET_CHARS (charset) == 96)
+               {
+                 if (((d = ch - (MIN_CHAR_96x96
+                                 +
+                                 (XCHARSET_FINAL (charset) - '0') * 96 * 96))
+                      >= 0)
+                     && (d < 96 * 96))
+                   return (((d / 96) + 32) << 8) | (d % 96 + 32);
+               }
+             else
+               return -1;
            }
            }
-         else
-           return -1;
        }
     }
        }
     }
-  if (EQ (charset, Vcharset_mojikyo_2022_1)
-      && (MIN_CHAR_MOJIKYO < ch) && (ch < MIN_CHAR_MOJIKYO + 94 * 60 * 94))
-    {
-      int m = ch - MIN_CHAR_MOJIKYO - 1;
-      int byte1 =  m / (94 * 60) + 33;
-      int byte2 = (m % (94 * 60)) / 94;
-      int byte3 =  m % 94 + 33;
-
-      if (byte2 < 30)
-       byte2 += 16 + 32;
-      else
-       byte2 += 18 + 32;
-      return (byte1 << 16) | (byte2 << 8) | byte3;
-    }
   return -1;
 }
 
   return -1;
 }
 
@@ -1224,6 +1236,16 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
       *charset = Vcharset_ucs_bmp;
       return c;
     }
       *charset = Vcharset_ucs_bmp;
       return c;
     }
+  else if (c <= MAX_CHAR_SMP)
+    {
+      *charset = Vcharset_ucs_smp;
+      return c - MIN_CHAR_SMP;
+    }
+  else if (c <= MAX_CHAR_SIP)
+    {
+      *charset = Vcharset_ucs_sip;
+      return c - MIN_CHAR_SIP;
+    }
   else if (c < MIN_CHAR_DAIKANWA)
     {
       *charset = Vcharset_ucs;
   else if (c < MIN_CHAR_DAIKANWA)
     {
       *charset = Vcharset_ucs;
@@ -1234,11 +1256,6 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
       *charset = Vcharset_ideograph_daikanwa;
       return c - MIN_CHAR_DAIKANWA;
     }
       *charset = Vcharset_ideograph_daikanwa;
       return c - MIN_CHAR_DAIKANWA;
     }
-  else if (c <= MAX_CHAR_MOJIKYO_0)
-    {
-      *charset = Vcharset_mojikyo;
-      return c - MIN_CHAR_MOJIKYO_0;
-    }
   else if (c < MIN_CHAR_94)
     {
       *charset = Vcharset_ucs;
   else if (c < MIN_CHAR_94)
     {
       *charset = Vcharset_ucs;
@@ -1300,16 +1317,6 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
          return c;
        }
     }
          return c;
        }
     }
-  else if (c < MIN_CHAR_MOJIKYO)
-    {
-      *charset = Vcharset_ucs;
-      return c;
-    }
-  else if (c <= MAX_CHAR_MOJIKYO)
-    {
-      *charset = Vcharset_mojikyo;
-      return c - MIN_CHAR_MOJIKYO;
-    }
   else
     {
       *charset = Vcharset_ucs;
   else
     {
       *charset = Vcharset_ucs;
@@ -1424,6 +1431,7 @@ character set.  Recognized properties are:
                this character set.
 'dimension     Number of octets used to index a character in this charset.
                Either 1 or 2.  Defaults to 1.
                this character set.
 'dimension     Number of octets used to index a character in this charset.
                Either 1 or 2.  Defaults to 1.
+               If UTF-2000 feature is enabled, 3 or 4 are also available.
 'columns       Number of columns used to display a character in this charset.
                Only used in TTY mode. (Under X, the actual width of a
                character can be derived from the font used to display the
 'columns       Number of columns used to display a character in this charset.
                Only used in TTY mode. (Under X, the actual width of a
                character can be derived from the font used to display the
@@ -1432,6 +1440,7 @@ character set.  Recognized properties are:
 'chars         Number of characters in each dimension (94 or 96).
                Defaults to 94.  Note that if the dimension is 2, the
                character set thus described is 94x94 or 96x96.
 'chars         Number of characters in each dimension (94 or 96).
                Defaults to 94.  Note that if the dimension is 2, the
                character set thus described is 94x94 or 96x96.
+               If UTF-2000 feature is enabled, 128 or 256 are also available.
 'final         Final byte of ISO 2022 escape sequence.  Must be
                supplied.  Each combination of (DIMENSION, CHARS) defines a
                separate namespace for final bytes.  Note that ISO
 'final         Final byte of ISO 2022 escape sequence.  Must be
                supplied.  Each combination of (DIMENSION, CHARS) defines a
                separate namespace for final bytes.  Note that ISO
@@ -1456,6 +1465,13 @@ character set.  Recognized properties are:
                is passed the octets of the character, with the high
                bit cleared and set depending upon whether the value
                of the 'graphic property is 0 or 1.
                is passed the octets of the character, with the high
                bit cleared and set depending upon whether the value
                of the 'graphic property is 0 or 1.
+'mother                [UTF-2000 only] Base coded-charset.
+'code-min      [UTF-2000 only] Minimum code-point of a base coded-charset.
+'code-max      [UTF-2000 only] Maximum code-point of a base coded-charset.
+'code-offset   [UTF-2000 only] Offset for a code-point of a base
+               coded-charset.
+'conversion    [UTF-2000 only] Conversion for a code-point of a base
+               coded-charset (94x60 or 94x94x60).
 */
        (name, doc_string, props))
 {
 */
        (name, doc_string, props))
 {
@@ -1465,7 +1481,10 @@ character set.  Recognized properties are:
   Lisp_Object charset;
   Lisp_Object ccl_program = Qnil;
   Lisp_Object short_name = Qnil, long_name = Qnil;
   Lisp_Object charset;
   Lisp_Object ccl_program = Qnil;
   Lisp_Object short_name = Qnil, long_name = Qnil;
+  Lisp_Object mother = Qnil;
+  int min_code = 0, max_code = 0, code_offset = 0;
   int byte_offset = -1;
   int byte_offset = -1;
+  int conversion = 0;
 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))
 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))
@@ -1494,7 +1513,13 @@ character set.  Recognized properties are:
          {
            CHECK_INT (value);
            dimension = XINT (value);
          {
            CHECK_INT (value);
            dimension = XINT (value);
-           if (dimension < 1 || dimension > 2)
+           if (dimension < 1 ||
+#ifdef UTF2000
+               dimension > 4
+#else
+               dimension > 2
+#endif
+               )
              signal_simple_error ("Invalid value for 'dimension", value);
          }
 
              signal_simple_error ("Invalid value for 'dimension", value);
          }
 
@@ -1502,7 +1527,11 @@ character set.  Recognized properties are:
          {
            CHECK_INT (value);
            chars = XINT (value);
          {
            CHECK_INT (value);
            chars = XINT (value);
-           if (chars != 94 && chars != 96)
+           if (chars != 94 && chars != 96
+#ifdef UTF2000
+               && chars != 128 && chars != 256
+#endif
+               )
              signal_simple_error ("Invalid value for 'chars", value);
          }
 
              signal_simple_error ("Invalid value for 'chars", value);
          }
 
@@ -1518,11 +1547,13 @@ character set.  Recognized properties are:
          {
            CHECK_INT (value);
            graphic = XINT (value);
          {
            CHECK_INT (value);
            graphic = XINT (value);
+           if (graphic < 0 ||
 #ifdef UTF2000
 #ifdef UTF2000
-           if (graphic < 0 || graphic > 2)
+               graphic > 2
 #else
 #else
-           if (graphic < 0 || graphic > 1)
+               graphic > 1
 #endif
 #endif
+               )
              signal_simple_error ("Invalid value for 'graphic", value);
          }
 
              signal_simple_error ("Invalid value for 'graphic", value);
          }
 
@@ -1550,6 +1581,41 @@ character set.  Recognized properties are:
              signal_simple_error ("Invalid value for 'final", value);
          }
 
              signal_simple_error ("Invalid value for 'final", value);
          }
 
+#ifdef UTF2000
+       else if (EQ (keyword, Qmother))
+         {
+           mother = Fget_charset (value);
+         }
+
+       else if (EQ (keyword, Qmin_code))
+         {
+           CHECK_INT (value);
+           min_code = XUINT (value);
+         }
+
+       else if (EQ (keyword, Qmax_code))
+         {
+           CHECK_INT (value);
+           max_code = XUINT (value);
+         }
+
+       else if (EQ (keyword, Qcode_offset))
+         {
+           CHECK_INT (value);
+           code_offset = XUINT (value);
+         }
+
+       else if (EQ (keyword, Qconversion))
+         {
+           if (EQ (value, Q94x60))
+             conversion = CONVERSION_94x60;
+           else if (EQ (value, Q94x94x60))
+             conversion = CONVERSION_94x94x60;
+           else
+             signal_simple_error ("Unrecognized conversion", value);
+         }
+
+#endif
        else if (EQ (keyword, Qccl_program))
          {
            struct ccl_program test_ccl;
        else if (EQ (keyword, Qccl_program))
          {
            struct ccl_program test_ccl;
@@ -1564,8 +1630,10 @@ character set.  Recognized properties are:
       }
   }
 
       }
   }
 
+#ifndef UTF2000
   if (!final)
     error ("'final must be specified");
   if (!final)
     error ("'final must be specified");
+#endif
   if (dimension == 2 && final > 0x5F)
     signal_simple_error
       ("Final must be in the range 0x30 - 0x5F for dimension == 2",
   if (dimension == 2 && final > 0x5F)
     signal_simple_error
       ("Final must be in the range 0x30 - 0x5F for dimension == 2",
@@ -1608,7 +1676,8 @@ character set.  Recognized properties are:
   charset = make_charset (id, name, chars, dimension, columns, graphic,
                          final, direction, short_name, long_name,
                          doc_string, registry,
   charset = make_charset (id, name, chars, dimension, columns, graphic,
                          final, direction, short_name, long_name,
                          doc_string, registry,
-                         Qnil, 0, 0, 0, byte_offset);
+                         Qnil, min_code, max_code, code_offset, byte_offset,
+                         mother, conversion);
   if (!NILP (ccl_program))
     XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return charset;
   if (!NILP (ccl_program))
     XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return charset;
@@ -1658,12 +1727,14 @@ NEW-NAME is the name of the new charset.  Return the new charset.
                              doc_string, registry,
 #ifdef UTF2000
                              CHARSET_DECODING_TABLE(cs),
                              doc_string, registry,
 #ifdef UTF2000
                              CHARSET_DECODING_TABLE(cs),
-                             CHARSET_UCS_MIN(cs),
-                             CHARSET_UCS_MAX(cs),
+                             CHARSET_MIN_CODE(cs),
+                             CHARSET_MAX_CODE(cs),
                              CHARSET_CODE_OFFSET(cs),
                              CHARSET_CODE_OFFSET(cs),
-                             CHARSET_BYTE_OFFSET(cs)
+                             CHARSET_BYTE_OFFSET(cs),
+                             CHARSET_MOTHER(cs),
+                             CHARSET_CONVERSION (cs)
 #else
 #else
-                             Qnil, 0, 0, 0, 0
+                             Qnil, 0, 0, 0, 0, Qnil, 0
 #endif
 );
 
 #endif
 );
 
@@ -1801,7 +1872,8 @@ Recognized properties are those listed in `make-charset', as well as
   if (EQ (prop, Qdimension))   return make_int (CHARSET_DIMENSION (cs));
   if (EQ (prop, Qcolumns))     return make_int (CHARSET_COLUMNS (cs));
   if (EQ (prop, Qgraphic))     return make_int (CHARSET_GRAPHIC (cs));
   if (EQ (prop, Qdimension))   return make_int (CHARSET_DIMENSION (cs));
   if (EQ (prop, Qcolumns))     return make_int (CHARSET_COLUMNS (cs));
   if (EQ (prop, Qgraphic))     return make_int (CHARSET_GRAPHIC (cs));
-  if (EQ (prop, Qfinal))       return make_char (CHARSET_FINAL (cs));
+  if (EQ (prop, Qfinal))       return CHARSET_FINAL (cs) == 0 ?
+                                Qnil : make_char (CHARSET_FINAL (cs));
   if (EQ (prop, Qchars))       return make_int (CHARSET_CHARS (cs));
   if (EQ (prop, Qregistry))    return CHARSET_REGISTRY (cs);
   if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
   if (EQ (prop, Qchars))       return make_int (CHARSET_CHARS (cs));
   if (EQ (prop, Qregistry))    return CHARSET_REGISTRY (cs);
   if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
@@ -1813,6 +1885,14 @@ Recognized properties are those listed in `make-charset', as well as
       /* #### Is this translation OK?  If so, error checking sufficient? */
       return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;
     }
       /* #### Is this translation OK?  If so, error checking sufficient? */
       return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;
     }
+#ifdef UTF2000
+  if (EQ (prop, Qmother))
+    return CHARSET_MOTHER (cs);
+  if (EQ (prop, Qmin_code))
+    return make_int (CHARSET_MIN_CODE (cs));
+  if (EQ (prop, Qmax_code))
+    return make_int (CHARSET_MAX_CODE (cs));
+#endif
   signal_simple_error ("Unrecognized charset property name", prop);
   return Qnil; /* not reached */
 }
   signal_simple_error ("Unrecognized charset property name", prop);
   return Qnil; /* not reached */
 }
@@ -1892,8 +1972,6 @@ Set mapping-table of CHARSET to TABLE.
 
   if (NILP (table))
     {
 
   if (NILP (table))
     {
-      if (VECTORP (CHARSET_DECODING_TABLE(cs)))
-       make_vector_newer (CHARSET_DECODING_TABLE(cs));
       CHARSET_DECODING_TABLE(cs) = Qnil;
       return table;
     }
       CHARSET_DECODING_TABLE(cs) = Qnil;
       return table;
     }
@@ -1928,8 +2006,8 @@ Set mapping-table of CHARSET to TABLE.
          Lisp_Object c = XVECTOR_DATA(table)[i];
 
          if (CHARP (c))
          Lisp_Object c = XVECTOR_DATA(table)[i];
 
          if (CHARP (c))
-           put_char_ccs_code_point (c, charset,
-                                    make_int (i + byte_offset));
+           Fput_char_attribute (c, XCHARSET_NAME (charset),
+                                make_int (i + byte_offset));
        }
       break;
     case 2:
        }
       break;
     case 2:
@@ -1946,16 +2024,16 @@ Set mapping-table of CHARSET to TABLE.
                  Lisp_Object c = XVECTOR_DATA(v)[j];
 
                  if (CHARP (c))
                  Lisp_Object c = XVECTOR_DATA(v)[j];
 
                  if (CHARP (c))
-                   put_char_ccs_code_point
-                     (c, charset,
+                   Fput_char_attribute
+                     (c, XCHARSET_NAME (charset),
                       make_int ( ( (i + byte_offset) << 8 )
                                  | (j + byte_offset)
                                  ) );
                }
            }
          else if (CHARP (v))
                       make_int ( ( (i + byte_offset) << 8 )
                                  | (j + byte_offset)
                                  ) );
                }
            }
          else if (CHARP (v))
-           put_char_ccs_code_point (v, charset,
-                                    make_int (i + byte_offset));
+           Fput_char_attribute (v, XCHARSET_NAME (charset),
+                                make_int (i + byte_offset));
        }
       break;
     }
        }
       break;
     }
@@ -1969,10 +2047,12 @@ Set mapping-table of CHARSET to TABLE.
 /************************************************************************/
 
 #ifdef UTF2000
 /************************************************************************/
 
 #ifdef UTF2000
-DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /*
+DEFUN ("decode-char", Fdecode_char, 2, 3, 0, /*
 Make a character from CHARSET and code-point CODE.
 Make a character from CHARSET and code-point CODE.
+If DEFINED_ONLY is non-nil, builtin character is not returned.
+If corresponding character is not found, nil is returned.
 */
 */
-       (charset, code))
+       (charset, code, defined_only))
 {
   int c;
 
 {
   int c;
 
@@ -1981,7 +2061,10 @@ Make a character from CHARSET and code-point CODE.
   c = XINT (code);
   if (XCHARSET_GRAPHIC (charset) == 1)
     c &= 0x7F7F7F7F;
   c = XINT (code);
   if (XCHARSET_GRAPHIC (charset) == 1)
     c &= 0x7F7F7F7F;
-  c = DECODE_CHAR (charset, c);
+  if (NILP (defined_only))
+    c = DECODE_CHAR (charset, c);
+  else
+    c = decode_defined_char (charset, c);
   return c >= 0 ? make_char (c) : Qnil;
 }
 
   return c >= 0 ? make_char (c) : Qnil;
 }
 
@@ -1996,7 +2079,7 @@ Make a builtin character from CHARSET and code-point CODE.
   CHECK_INT (code);
   if (EQ (charset, Vcharset_latin_viscii))
     {
   CHECK_INT (code);
   if (EQ (charset, Vcharset_latin_viscii))
     {
-      Lisp_Object chr = Fdecode_char (charset, code);
+      Lisp_Object chr = Fdecode_char (charset, code, Qnil);
       Lisp_Object ret;
 
       if (!NILP (chr))
       Lisp_Object ret;
 
       if (!NILP (chr))
@@ -2025,7 +2108,7 @@ Make a builtin character from CHARSET and code-point CODE.
     c &= 0x7F7F7F7F;
 #endif
   c = decode_builtin_char (charset, c);
     c &= 0x7F7F7F7F;
 #endif
   c = decode_builtin_char (charset, c);
-  return c >= 0 ? make_char (c) : Fdecode_char (charset, code);
+  return c >= 0 ? make_char (c) : Fdecode_char (charset, code, Qnil);
 }
 #endif
 
 }
 #endif
 
@@ -2120,6 +2203,25 @@ N defaults to 0 if omitted.
     signal_simple_error ("Octet number must be 0 or 1", n);
 }
 
     signal_simple_error ("Octet number must be 0 or 1", n);
 }
 
+#ifdef UTF2000
+DEFUN ("encode-char", Fencode_char, 2, 3, 0, /*
+Return code-point of CHARACTER in specified CHARSET.
+*/
+       (character, charset, defined_only))
+{
+  int code_point;
+
+  CHECK_CHAR_COERCE_INT (character);
+  charset = Fget_charset (charset);
+  code_point = charset_code_point (charset, XCHAR (character),
+                                  !NILP (defined_only));
+  if (code_point >= 0)
+    return make_int (code_point);
+  else
+    return Qnil;
+}
+#endif
+
 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
 Return list of charset and one or two position-codes of CHARACTER.
 */
 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
 Return list of charset and one or two position-codes of CHARACTER.
 */
@@ -2276,6 +2378,7 @@ syms_of_mule_charset (void)
 #ifdef UTF2000
   DEFSUBR (Fdecode_char);
   DEFSUBR (Fdecode_builtin_char);
 #ifdef UTF2000
   DEFSUBR (Fdecode_char);
   DEFSUBR (Fdecode_builtin_char);
+  DEFSUBR (Fencode_char);
 #endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
 #endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
@@ -2295,6 +2398,15 @@ syms_of_mule_charset (void)
   defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
   defsymbol (&Qshort_name, "short-name");
   defsymbol (&Qlong_name, "long-name");
   defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
   defsymbol (&Qshort_name, "short-name");
   defsymbol (&Qlong_name, "long-name");
+#ifdef UTF2000
+  defsymbol (&Qmother, "mother");
+  defsymbol (&Qmin_code, "min-code");
+  defsymbol (&Qmax_code, "max-code");
+  defsymbol (&Qcode_offset, "code-offset");
+  defsymbol (&Qconversion, "conversion");
+  defsymbol (&Q94x60, "94x60");
+  defsymbol (&Q94x94x60, "94x94x60");
+#endif
 
   defsymbol (&Ql2r, "l2r");
   defsymbol (&Qr2l, "r2l");
 
   defsymbol (&Ql2r, "l2r");
   defsymbol (&Qr2l, "r2l");
@@ -2327,8 +2439,11 @@ syms_of_mule_charset (void)
 #ifdef UTF2000
   defsymbol (&Qucs,                    "ucs");
   defsymbol (&Qucs_bmp,                        "ucs-bmp");
 #ifdef UTF2000
   defsymbol (&Qucs,                    "ucs");
   defsymbol (&Qucs_bmp,                        "ucs-bmp");
+  defsymbol (&Qucs_smp,                        "ucs-smp");
+  defsymbol (&Qucs_sip,                        "ucs-sip");
   defsymbol (&Qucs_cns,                        "ucs-cns");
   defsymbol (&Qucs_jis,                        "ucs-jis");
   defsymbol (&Qucs_cns,                        "ucs-cns");
   defsymbol (&Qucs_jis,                        "ucs-jis");
+  defsymbol (&Qucs_ks,                 "ucs-ks");
   defsymbol (&Qucs_big5,               "ucs-big5");
   defsymbol (&Qlatin_viscii,           "latin-viscii");
   defsymbol (&Qlatin_tcvn5712,         "latin-tcvn5712");
   defsymbol (&Qucs_big5,               "ucs-big5");
   defsymbol (&Qlatin_viscii,           "latin-viscii");
   defsymbol (&Qlatin_tcvn5712,         "latin-tcvn5712");
@@ -2336,6 +2451,7 @@ syms_of_mule_charset (void)
   defsymbol (&Qlatin_viscii_upper,     "latin-viscii-upper");
   defsymbol (&Qvietnamese_viscii_lower,        "vietnamese-viscii-lower");
   defsymbol (&Qvietnamese_viscii_upper,        "vietnamese-viscii-upper");
   defsymbol (&Qlatin_viscii_upper,     "latin-viscii-upper");
   defsymbol (&Qvietnamese_viscii_lower,        "vietnamese-viscii-lower");
   defsymbol (&Qvietnamese_viscii_upper,        "vietnamese-viscii-upper");
+  defsymbol (&Qjis_x0208,              "=jis-x0208");
   defsymbol (&Qideograph_gt,           "ideograph-gt");
   defsymbol (&Qideograph_gt_pj_1,      "ideograph-gt-pj-1");
   defsymbol (&Qideograph_gt_pj_2,      "ideograph-gt-pj-2");
   defsymbol (&Qideograph_gt,           "ideograph-gt");
   defsymbol (&Qideograph_gt_pj_1,      "ideograph-gt-pj-1");
   defsymbol (&Qideograph_gt_pj_2,      "ideograph-gt-pj-2");
@@ -2348,32 +2464,24 @@ syms_of_mule_charset (void)
   defsymbol (&Qideograph_gt_pj_9,      "ideograph-gt-pj-9");
   defsymbol (&Qideograph_gt_pj_10,     "ideograph-gt-pj-10");
   defsymbol (&Qideograph_gt_pj_11,     "ideograph-gt-pj-11");
   defsymbol (&Qideograph_gt_pj_9,      "ideograph-gt-pj-9");
   defsymbol (&Qideograph_gt_pj_10,     "ideograph-gt-pj-10");
   defsymbol (&Qideograph_gt_pj_11,     "ideograph-gt-pj-11");
+  defsymbol (&Qideograph_daikanwa_2,   "ideograph-daikanwa-2");
   defsymbol (&Qideograph_daikanwa,     "ideograph-daikanwa");
   defsymbol (&Qchinese_big5,           "chinese-big5");
   defsymbol (&Qideograph_daikanwa,     "ideograph-daikanwa");
   defsymbol (&Qchinese_big5,           "chinese-big5");
-  defsymbol (&Qchinese_big5_cdp,       "chinese-big5-cdp");
-  defsymbol (&Qmojikyo,                        "mojikyo");
-  defsymbol (&Qmojikyo_2022_1,         "mojikyo-2022-1");
-  defsymbol (&Qmojikyo_pj_1,           "mojikyo-pj-1");
-  defsymbol (&Qmojikyo_pj_2,           "mojikyo-pj-2");
-  defsymbol (&Qmojikyo_pj_3,           "mojikyo-pj-3");
-  defsymbol (&Qmojikyo_pj_4,           "mojikyo-pj-4");
-  defsymbol (&Qmojikyo_pj_5,           "mojikyo-pj-5");
-  defsymbol (&Qmojikyo_pj_6,           "mojikyo-pj-6");
-  defsymbol (&Qmojikyo_pj_7,           "mojikyo-pj-7");
-  defsymbol (&Qmojikyo_pj_8,           "mojikyo-pj-8");
-  defsymbol (&Qmojikyo_pj_9,           "mojikyo-pj-9");
-  defsymbol (&Qmojikyo_pj_10,          "mojikyo-pj-10");
-  defsymbol (&Qmojikyo_pj_11,          "mojikyo-pj-11");
-  defsymbol (&Qmojikyo_pj_12,          "mojikyo-pj-12");
-  defsymbol (&Qmojikyo_pj_13,          "mojikyo-pj-13");
-  defsymbol (&Qmojikyo_pj_14,          "mojikyo-pj-14");
-  defsymbol (&Qmojikyo_pj_15,          "mojikyo-pj-15");
-  defsymbol (&Qmojikyo_pj_16,          "mojikyo-pj-16");
-  defsymbol (&Qmojikyo_pj_17,          "mojikyo-pj-17");
-  defsymbol (&Qmojikyo_pj_18,          "mojikyo-pj-18");
-  defsymbol (&Qmojikyo_pj_19,          "mojikyo-pj-19");
-  defsymbol (&Qmojikyo_pj_20,          "mojikyo-pj-20");
-  defsymbol (&Qmojikyo_pj_21,          "mojikyo-pj-21");
+  /*  defsymbol (&Qchinese_big5_cdp,   "chinese-big5-cdp"); */
+  defsymbol (&Qideograph_hanziku_1,    "ideograph-hanziku-1");
+  defsymbol (&Qideograph_hanziku_2,    "ideograph-hanziku-2");
+  defsymbol (&Qideograph_hanziku_3,    "ideograph-hanziku-3");
+  defsymbol (&Qideograph_hanziku_4,    "ideograph-hanziku-4");
+  defsymbol (&Qideograph_hanziku_5,    "ideograph-hanziku-5");
+  defsymbol (&Qideograph_hanziku_6,    "ideograph-hanziku-6");
+  defsymbol (&Qideograph_hanziku_7,    "ideograph-hanziku-7");
+  defsymbol (&Qideograph_hanziku_8,    "ideograph-hanziku-8");
+  defsymbol (&Qideograph_hanziku_9,    "ideograph-hanziku-9");
+  defsymbol (&Qideograph_hanziku_10,   "ideograph-hanziku-10");
+  defsymbol (&Qideograph_hanziku_11,   "ideograph-hanziku-11");
+  defsymbol (&Qideograph_hanziku_12,   "ideograph-hanziku-12");
+  defsymbol (&Qchina3_jef,             "china3-jef");
+  defsymbol (&Qideograph_cbeta,                "ideograph-cbeta");
   defsymbol (&Qethiopic_ucs,           "ethiopic-ucs");
 #endif
   defsymbol (&Qchinese_big5_1,         "chinese-big5-1");
   defsymbol (&Qethiopic_ucs,           "ethiopic-ucs");
 #endif
   defsymbol (&Qchinese_big5_1,         "chinese-big5-1");
@@ -2453,43 +2561,74 @@ complex_vars_of_mule_charset (void)
                  build_string ("UCS"),
                  build_string ("ISO/IEC 10646"),
                  build_string (""),
                  build_string ("UCS"),
                  build_string ("ISO/IEC 10646"),
                  build_string (""),
-                 Qnil, 0, 0xFFFFFFF, 0, 0);
+                 Qnil, 0, 0x7FFFFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ucs_bmp);
   Vcharset_ucs_bmp =
     make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
                  1, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("BMP"),
   staticpro (&Vcharset_ucs_bmp);
   Vcharset_ucs_bmp =
     make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
                  1, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("BMP"),
-                 build_string ("BMP"),
+                 build_string ("UCS-BMP"),
                  build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
                  build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
-                 build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
-                 Qnil, 0, 0xFFFF, 0, 0);
+                 build_string
+                 ("\\(ISO10646.*-[01]\\|UCS00-0\\|UNICODE[23]?-0\\)"),
+                 Qnil, 0, 0xFFFF, 0, 0, Qnil, CONVERSION_IDENTICAL);
+  staticpro (&Vcharset_ucs_smp);
+  Vcharset_ucs_smp =
+    make_charset (LEADING_BYTE_UCS_SMP, Qucs_smp, 256, 2,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("SMP"),
+                 build_string ("UCS-SMP"),
+                 build_string ("ISO/IEC 10646 Group 0 Plane 1 (SMP)"),
+                 build_string ("UCS00-1"),
+                 Qnil, MIN_CHAR_SMP, MAX_CHAR_SMP,
+                 MIN_CHAR_SMP, 0, Qnil, CONVERSION_IDENTICAL);
+  staticpro (&Vcharset_ucs_sip);
+  Vcharset_ucs_sip =
+    make_charset (LEADING_BYTE_UCS_SIP, Qucs_sip, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("SIP"),
+                 build_string ("UCS-SIP"),
+                 build_string ("ISO/IEC 10646 Group 0 Plane 2 (SIP)"),
+                 build_string ("\\(ISO10646.*-2\\|UCS00-2\\)"),
+                 Qnil, MIN_CHAR_SIP, MAX_CHAR_SIP,
+                 MIN_CHAR_SIP, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ucs_cns);
   Vcharset_ucs_cns =
     make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3,
   staticpro (&Vcharset_ucs_cns);
   Vcharset_ucs_cns =
     make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3,
-                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("UCS for CNS"),
                  build_string ("UCS for CNS 11643"),
                  build_string ("ISO/IEC 10646 for CNS 11643"),
                  build_string (""),
                  build_string ("UCS for CNS"),
                  build_string ("UCS for CNS 11643"),
                  build_string ("ISO/IEC 10646 for CNS 11643"),
                  build_string (""),
-                 Qnil, 0, 0, 0, 0);
+                 Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ucs_jis);
   Vcharset_ucs_jis =
     make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3,
   staticpro (&Vcharset_ucs_jis);
   Vcharset_ucs_jis =
     make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3,
-                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("UCS for JIS"),
                  build_string ("UCS for JIS X 0208, 0212 and 0213"),
                  build_string ("UCS for JIS"),
                  build_string ("UCS for JIS X 0208, 0212 and 0213"),
-                 build_string ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"),
+                 build_string
+                 ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"),
                  build_string (""),
                  build_string (""),
-                 Qnil, 0, 0, 0, 0);
+                 Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
+  staticpro (&Vcharset_ucs_ks);
+  Vcharset_ucs_ks =
+    make_charset (LEADING_BYTE_UCS_KS, Qucs_ks, 256, 3,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("UCS for KS"),
+                 build_string ("UCS for CCS defined by KS"),
+                 build_string ("ISO/IEC 10646 for Korean Standards"),
+                 build_string (""),
+                 Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ucs_big5);
   Vcharset_ucs_big5 =
     make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3,
   staticpro (&Vcharset_ucs_big5);
   Vcharset_ucs_big5 =
     make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3,
-                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("UCS for Big5"),
                  build_string ("UCS for Big5"),
                  build_string ("ISO/IEC 10646 for Big5"),
                  build_string (""),
                  build_string ("UCS for Big5"),
                  build_string ("UCS for Big5"),
                  build_string ("ISO/IEC 10646 for Big5"),
                  build_string (""),
-                 Qnil, 0, 0, 0, 0);
+                 Qnil, 0, 0, 0, 0, Vcharset_ucs, CONVERSION_IDENTICAL);
 #else
 # define MIN_CHAR_THAI 0
 # define MAX_CHAR_THAI 0
 #else
 # define MIN_CHAR_THAI 0
 # define MAX_CHAR_THAI 0
@@ -2506,7 +2645,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ASCII)"),
                  build_string ("ASCII (ISO646 IRV)"),
                  build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
                  build_string ("ASCII)"),
                  build_string ("ASCII (ISO646 IRV)"),
                  build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
-                 Qnil, 0, 0x7F, 0, 0);
+                 Qnil, 0, 0x7F, 0, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_control_1);
   Vcharset_control_1 =
     make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
   staticpro (&Vcharset_control_1);
   Vcharset_control_1 =
     make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
@@ -2515,7 +2654,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("Control characters"),
                  build_string ("Control characters 128-191"),
                  build_string (""),
                  build_string ("Control characters"),
                  build_string ("Control characters 128-191"),
                  build_string (""),
-                 Qnil, 0x80, 0x9F, 0, 0);
+                 Qnil, 0x80, 0x9F, 0x80, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_iso8859_1);
   Vcharset_latin_iso8859_1 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
   staticpro (&Vcharset_latin_iso8859_1);
   Vcharset_latin_iso8859_1 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
@@ -2524,7 +2663,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("iso8859-1"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("iso8859-1"),
-                 Qnil, 0xA0, 0xFF, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_iso8859_2);
   Vcharset_latin_iso8859_2 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
   staticpro (&Vcharset_latin_iso8859_2);
   Vcharset_latin_iso8859_2 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
@@ -2533,7 +2672,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("iso8859-2"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("iso8859-2"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_iso8859_3);
   Vcharset_latin_iso8859_3 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
   staticpro (&Vcharset_latin_iso8859_3);
   Vcharset_latin_iso8859_3 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
@@ -2542,7 +2681,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("iso8859-3"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("iso8859-3"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_iso8859_4);
   Vcharset_latin_iso8859_4 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
   staticpro (&Vcharset_latin_iso8859_4);
   Vcharset_latin_iso8859_4 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
@@ -2551,7 +2690,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("iso8859-4"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("iso8859-4"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =
     make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
   staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =
     make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
@@ -2560,7 +2699,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("TIS620 (Thai)"),
                  build_string ("TIS620.2529 (Thai)"),
                  build_string ("tis620"),
                  build_string ("TIS620 (Thai)"),
                  build_string ("TIS620.2529 (Thai)"),
                  build_string ("tis620"),
-                 Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_greek_iso8859_7);
   Vcharset_greek_iso8859_7 =
     make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
   staticpro (&Vcharset_greek_iso8859_7);
   Vcharset_greek_iso8859_7 =
     make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
@@ -2569,7 +2708,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("iso8859-7"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("iso8859-7"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_arabic_iso8859_6);
   Vcharset_arabic_iso8859_6 =
     make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
   staticpro (&Vcharset_arabic_iso8859_6);
   Vcharset_arabic_iso8859_6 =
     make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
@@ -2578,7 +2717,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("iso8859-6"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("iso8859-6"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_hebrew_iso8859_8);
   Vcharset_hebrew_iso8859_8 =
     make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
   staticpro (&Vcharset_hebrew_iso8859_8);
   Vcharset_hebrew_iso8859_8 =
     make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
@@ -2589,7 +2728,8 @@ complex_vars_of_mule_charset (void)
                  build_string ("iso8859-8"),
                  Qnil,
                  0 /* MIN_CHAR_HEBREW */,
                  build_string ("iso8859-8"),
                  Qnil,
                  0 /* MIN_CHAR_HEBREW */,
-                 0 /* MAX_CHAR_HEBREW */, 0, 32);
+                 0 /* MAX_CHAR_HEBREW */, 0, 32,
+                 Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_katakana_jisx0201);
   Vcharset_katakana_jisx0201 =
     make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
   staticpro (&Vcharset_katakana_jisx0201);
   Vcharset_katakana_jisx0201 =
     make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
@@ -2598,7 +2738,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("JISX0201.1976 (Japanese Kana)"),
                  build_string ("JISX0201.1976 Japanese Kana"),
                  build_string ("jisx0201\\.1976"),
                  build_string ("JISX0201.1976 (Japanese Kana)"),
                  build_string ("JISX0201.1976 Japanese Kana"),
                  build_string ("jisx0201\\.1976"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_jisx0201);
   Vcharset_latin_jisx0201 =
     make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
   staticpro (&Vcharset_latin_jisx0201);
   Vcharset_latin_jisx0201 =
     make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
@@ -2607,7 +2747,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("JISX0201.1976 (Japanese Roman)"),
                  build_string ("JISX0201.1976 Japanese Roman"),
                  build_string ("jisx0201\\.1976"),
                  build_string ("JISX0201.1976 (Japanese Roman)"),
                  build_string ("JISX0201.1976 Japanese Roman"),
                  build_string ("jisx0201\\.1976"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_cyrillic_iso8859_5);
   Vcharset_cyrillic_iso8859_5 =
     make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
   staticpro (&Vcharset_cyrillic_iso8859_5);
   Vcharset_cyrillic_iso8859_5 =
     make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
@@ -2616,7 +2756,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("iso8859-5"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("iso8859-5"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_iso8859_9);
   Vcharset_latin_iso8859_9 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
   staticpro (&Vcharset_latin_iso8859_9);
   Vcharset_latin_iso8859_9 =
     make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
@@ -2625,7 +2765,22 @@ complex_vars_of_mule_charset (void)
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("iso8859-9"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("iso8859-9"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
+#ifdef UTF2000
+  staticpro (&Vcharset_jis_x0208);
+  Vcharset_jis_x0208 =
+    make_charset (LEADING_BYTE_JIS_X0208,
+                 Qjis_x0208, 94, 2,
+                 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("JIS X0208"),
+                 build_string ("JIS X0208 Common"),
+                 build_string ("JIS X0208 Common part"),
+                 build_string ("jisx0208\\.1990"),
+                 Qnil,
+                 MIN_CHAR_JIS_X0208_1990,
+                 MAX_CHAR_JIS_X0208_1990, MIN_CHAR_JIS_X0208_1990, 33,
+                 Qnil, CONVERSION_94x94);
+#endif
   staticpro (&Vcharset_japanese_jisx0208_1978);
   Vcharset_japanese_jisx0208_1978 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
   staticpro (&Vcharset_japanese_jisx0208_1978);
   Vcharset_japanese_jisx0208_1978 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
@@ -2636,7 +2791,13 @@ complex_vars_of_mule_charset (void)
                  build_string
                  ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
                  build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
                  build_string
                  ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
                  build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33,
+#ifdef UTF2000
+                 Vcharset_jis_x0208,
+#else
+                 Qnil,
+#endif
+                 CONVERSION_IDENTICAL);
   staticpro (&Vcharset_chinese_gb2312);
   Vcharset_chinese_gb2312 =
     make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
   staticpro (&Vcharset_chinese_gb2312);
   Vcharset_chinese_gb2312 =
     make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
@@ -2645,7 +2806,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("GB2312)"),
                  build_string ("GB2312 Chinese simplified"),
                  build_string ("gb2312"),
                  build_string ("GB2312)"),
                  build_string ("GB2312 Chinese simplified"),
                  build_string ("gb2312"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_chinese_gb12345);
   Vcharset_chinese_gb12345 =
     make_charset (LEADING_BYTE_CHINESE_GB12345, Qchinese_gb12345, 94, 2,
   staticpro (&Vcharset_chinese_gb12345);
   Vcharset_chinese_gb12345 =
     make_charset (LEADING_BYTE_CHINESE_GB12345, Qchinese_gb12345, 94, 2,
@@ -2654,7 +2815,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("GB 12345)"),
                  build_string ("GB 12345-1990"),
                  build_string ("GB12345\\(\\.1990\\)?-0"),
                  build_string ("GB 12345)"),
                  build_string ("GB 12345-1990"),
                  build_string ("GB12345\\(\\.1990\\)?-0"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_japanese_jisx0208);
   Vcharset_japanese_jisx0208 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2,
   staticpro (&Vcharset_japanese_jisx0208);
   Vcharset_japanese_jisx0208 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2,
@@ -2663,7 +2824,13 @@ complex_vars_of_mule_charset (void)
                  build_string ("JIS X0208:1983 (Japanese)"),
                  build_string ("JIS X0208:1983 Japanese Kanji"),
                  build_string ("jisx0208\\.1983"),
                  build_string ("JIS X0208:1983 (Japanese)"),
                  build_string ("JIS X0208:1983 Japanese Kanji"),
                  build_string ("jisx0208\\.1983"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33,
+#ifdef UTF2000
+                 Vcharset_jis_x0208,
+#else
+                 Qnil,
+#endif
+                 CONVERSION_IDENTICAL);
 #ifdef UTF2000
   staticpro (&Vcharset_japanese_jisx0208_1990);
   Vcharset_japanese_jisx0208_1990 =
 #ifdef UTF2000
   staticpro (&Vcharset_japanese_jisx0208_1990);
   Vcharset_japanese_jisx0208_1990 =
@@ -2675,8 +2842,11 @@ complex_vars_of_mule_charset (void)
                  build_string ("JIS X0208:1990 Japanese Kanji"),
                  build_string ("jisx0208\\.1990"),
                  Qnil,
                  build_string ("JIS X0208:1990 Japanese Kanji"),
                  build_string ("jisx0208\\.1990"),
                  Qnil,
-                 MIN_CHAR_JIS_X0208_1990,
-                 MAX_CHAR_JIS_X0208_1990, 0, 33);
+                 0x2121 /* MIN_CHAR_JIS_X0208_1990 */,
+                 0x7426 /* MAX_CHAR_JIS_X0208_1990 */,
+                 0 /* MIN_CHAR_JIS_X0208_1990 */, 33,
+                 Vcharset_jis_x0208 /* Qnil */,
+                 CONVERSION_IDENTICAL /* CONVERSION_94x94 */);
 #endif
   staticpro (&Vcharset_korean_ksc5601);
   Vcharset_korean_ksc5601 =
 #endif
   staticpro (&Vcharset_korean_ksc5601);
   Vcharset_korean_ksc5601 =
@@ -2686,7 +2856,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("KSC5601 (Korean"),
                  build_string ("KSC5601 Korean Hangul and Hanja"),
                  build_string ("ksc5601"),
                  build_string ("KSC5601 (Korean"),
                  build_string ("KSC5601 Korean Hangul and Hanja"),
                  build_string ("ksc5601"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_japanese_jisx0212);
   Vcharset_japanese_jisx0212 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
   staticpro (&Vcharset_japanese_jisx0212);
   Vcharset_japanese_jisx0212 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
@@ -2695,7 +2865,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("JISX0212 (Japanese)"),
                  build_string ("JISX0212 Japanese Supplement"),
                  build_string ("jisx0212"),
                  build_string ("JISX0212 (Japanese)"),
                  build_string ("JISX0212 Japanese Supplement"),
                  build_string ("jisx0212"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
 
 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
   staticpro (&Vcharset_chinese_cns11643_1);
 
 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
   staticpro (&Vcharset_chinese_cns11643_1);
@@ -2707,7 +2877,7 @@ complex_vars_of_mule_charset (void)
                  build_string
                  ("CNS 11643 Plane 1 Chinese traditional"),
                  build_string (CHINESE_CNS_PLANE_RE("1")),
                  build_string
                  ("CNS 11643 Plane 1 Chinese traditional"),
                  build_string (CHINESE_CNS_PLANE_RE("1")),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_chinese_cns11643_2);
   Vcharset_chinese_cns11643_2 =
     make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
   staticpro (&Vcharset_chinese_cns11643_2);
   Vcharset_chinese_cns11643_2 =
     make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
@@ -2717,7 +2887,7 @@ complex_vars_of_mule_charset (void)
                  build_string
                  ("CNS 11643 Plane 2 Chinese traditional"),
                  build_string (CHINESE_CNS_PLANE_RE("2")),
                  build_string
                  ("CNS 11643 Plane 2 Chinese traditional"),
                  build_string (CHINESE_CNS_PLANE_RE("2")),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
 #ifdef UTF2000
   staticpro (&Vcharset_latin_tcvn5712);
   Vcharset_latin_tcvn5712 =
 #ifdef UTF2000
   staticpro (&Vcharset_latin_tcvn5712);
   Vcharset_latin_tcvn5712 =
@@ -2727,7 +2897,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("TCVN 5712 (VSCII-2)"),
                  build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
                  build_string ("tcvn5712\\(\\.1993\\)?-1"),
                  build_string ("TCVN 5712 (VSCII-2)"),
                  build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
                  build_string ("tcvn5712\\(\\.1993\\)?-1"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_viscii_lower);
   Vcharset_latin_viscii_lower =
     make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
   staticpro (&Vcharset_latin_viscii_lower);
   Vcharset_latin_viscii_lower =
     make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
@@ -2736,7 +2906,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("VISCII lower (Vietnamese)"),
                  build_string ("VISCII lower (Vietnamese)"),
                  build_string ("MULEVISCII-LOWER"),
                  build_string ("VISCII lower (Vietnamese)"),
                  build_string ("VISCII lower (Vietnamese)"),
                  build_string ("MULEVISCII-LOWER"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_viscii_upper);
   Vcharset_latin_viscii_upper =
     make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
   staticpro (&Vcharset_latin_viscii_upper);
   Vcharset_latin_viscii_upper =
     make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
@@ -2745,7 +2915,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("VISCII upper (Vietnamese)"),
                  build_string ("VISCII upper (Vietnamese)"),
                  build_string ("MULEVISCII-UPPER"),
                  build_string ("VISCII upper (Vietnamese)"),
                  build_string ("VISCII upper (Vietnamese)"),
                  build_string ("MULEVISCII-UPPER"),
-                 Qnil, 0, 0, 0, 32);
+                 Qnil, 0, 0, 0, 32, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_latin_viscii);
   Vcharset_latin_viscii =
     make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
   staticpro (&Vcharset_latin_viscii);
   Vcharset_latin_viscii =
     make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
@@ -2754,7 +2924,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("VISCII 1.1 (Vietnamese)"),
                  build_string ("VISCII 1.1 (Vietnamese)"),
                  build_string ("VISCII1\\.1"),
                  build_string ("VISCII 1.1 (Vietnamese)"),
                  build_string ("VISCII 1.1 (Vietnamese)"),
                  build_string ("VISCII1\\.1"),
-                 Qnil, 0, 0, 0, 0);
+                 Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_chinese_big5);
   Vcharset_chinese_big5 =
     make_charset (LEADING_BYTE_CHINESE_BIG5, Qchinese_big5, 256, 2,
   staticpro (&Vcharset_chinese_big5);
   Vcharset_chinese_big5 =
     make_charset (LEADING_BYTE_CHINESE_BIG5, Qchinese_big5, 256, 2,
@@ -2762,8 +2932,11 @@ complex_vars_of_mule_charset (void)
                  build_string ("Big5"),
                  build_string ("Big5"),
                  build_string ("Big5 Chinese traditional"),
                  build_string ("Big5"),
                  build_string ("Big5"),
                  build_string ("Big5 Chinese traditional"),
-                 build_string ("big5"),
-                 Qnil, 0, 0, 0, 0);
+                 build_string ("big5-0"),
+                 Qnil,
+                 MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
+                 MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
+#if 0
   staticpro (&Vcharset_chinese_big5_cdp);
   Vcharset_chinese_big5_cdp =
     make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2,
   staticpro (&Vcharset_chinese_big5_cdp);
   Vcharset_chinese_big5_cdp =
     make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2,
@@ -2772,7 +2945,53 @@ complex_vars_of_mule_charset (void)
                  build_string ("Big5 + CDP extension"),
                  build_string ("Big5 with CDP extension"),
                  build_string ("big5\\.cdp-0"),
                  build_string ("Big5 + CDP extension"),
                  build_string ("Big5 with CDP extension"),
                  build_string ("big5\\.cdp-0"),
-                 Qnil, 0, 0, 0, 0);
+                 Qnil, MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
+                 MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
+#endif
+#define DEF_HANZIKU(n)                                                 \
+  staticpro (&Vcharset_ideograph_hanziku_##n);                         \
+  Vcharset_ideograph_hanziku_##n =                                     \
+    make_charset (LEADING_BYTE_HANZIKU_##n, Qideograph_hanziku_##n, 256, 2, \
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,                       \
+                 build_string ("HZK-"#n),                              \
+                 build_string ("HANZIKU-"#n),  \
+                 build_string ("HANZIKU (pseudo BIG5 encoding) part "#n), \
+                 build_string                                          \
+                 ("hanziku-"#n"$"),                                    \
+                 Qnil, MIN_CHAR_HANZIKU_##n, MAX_CHAR_HANZIKU_##n,     \
+                 MIN_CHAR_HANZIKU_##n, 0, Qnil, CONVERSION_IDENTICAL);
+  DEF_HANZIKU (1);
+  DEF_HANZIKU (2);
+  DEF_HANZIKU (3);
+  DEF_HANZIKU (4);
+  DEF_HANZIKU (5);
+  DEF_HANZIKU (6);
+  DEF_HANZIKU (7);
+  DEF_HANZIKU (8);
+  DEF_HANZIKU (9);
+  DEF_HANZIKU (10);
+  DEF_HANZIKU (11);
+  DEF_HANZIKU (12);
+  staticpro (&Vcharset_china3_jef);
+  Vcharset_china3_jef =
+    make_charset (LEADING_BYTE_CHINA3_JEF, Qchina3_jef, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("JC3"),
+                 build_string ("JEF + CHINA3"),
+                 build_string ("JEF + CHINA3 private characters"),
+                 build_string ("china3jef-0"),
+                 Qnil, MIN_CHAR_CHINA3_JEF, MAX_CHAR_CHINA3_JEF,
+                 MIN_CHAR_CHINA3_JEF, 0, Qnil, CONVERSION_IDENTICAL);
+  staticpro (&Vcharset_ideograph_cbeta);
+  Vcharset_ideograph_cbeta =
+    make_charset (LEADING_BYTE_CBETA, Qideograph_cbeta, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("CB"),
+                 build_string ("CBETA"),
+                 build_string ("CBETA private characters"),
+                 build_string ("cbeta-0"),
+                 Qnil, MIN_CHAR_CBETA, MAX_CHAR_CBETA,
+                 MIN_CHAR_CBETA, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ideograph_gt);
   Vcharset_ideograph_gt =
     make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3,
   staticpro (&Vcharset_ideograph_gt);
   Vcharset_ideograph_gt =
     make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3,
@@ -2781,7 +3000,8 @@ complex_vars_of_mule_charset (void)
                  build_string ("GT"),
                  build_string ("GT"),
                  build_string (""),
                  build_string ("GT"),
                  build_string ("GT"),
                  build_string (""),
-                 Qnil, MIN_CHAR_GT, MAX_CHAR_GT, 0, 0);
+                 Qnil, MIN_CHAR_GT, MAX_CHAR_GT,
+                 MIN_CHAR_GT, 0, Qnil, CONVERSION_IDENTICAL);
 #define DEF_GT_PJ(n)                                                   \
   staticpro (&Vcharset_ideograph_gt_pj_##n);                           \
   Vcharset_ideograph_gt_pj_##n =                                       \
 #define DEF_GT_PJ(n)                                                   \
   staticpro (&Vcharset_ideograph_gt_pj_##n);                           \
   Vcharset_ideograph_gt_pj_##n =                                       \
@@ -2792,7 +3012,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("GT 2000 (pseudo JIS encoding) part "#n), \
                  build_string                                          \
                  ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"),  \
                  build_string ("GT 2000 (pseudo JIS encoding) part "#n), \
                  build_string                                          \
                  ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"),  \
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   DEF_GT_PJ (1);
   DEF_GT_PJ (2);
   DEF_GT_PJ (3);
   DEF_GT_PJ (1);
   DEF_GT_PJ (2);
   DEF_GT_PJ (3);
@@ -2805,68 +3025,27 @@ complex_vars_of_mule_charset (void)
   DEF_GT_PJ (10);
   DEF_GT_PJ (11);
 
   DEF_GT_PJ (10);
   DEF_GT_PJ (11);
 
+  staticpro (&Vcharset_ideograph_daikanwa_2);
+  Vcharset_ideograph_daikanwa_2 =
+    make_charset (LEADING_BYTE_DAIKANWA_2, Qideograph_daikanwa_2, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Daikanwa Rev."),
+                 build_string ("Morohashi's Daikanwa Rev."),
+                 build_string
+                 ("Daikanwa dictionary (revised version)"),
+                 build_string ("Daikanwa\\(\\.[0-9]+\\)?-2"),
+                 Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_ideograph_daikanwa);
   Vcharset_ideograph_daikanwa =
   staticpro (&Vcharset_ideograph_daikanwa);
   Vcharset_ideograph_daikanwa =
-    make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2,
+    make_charset (LEADING_BYTE_DAIKANWA_3, Qideograph_daikanwa, 256, 2,
                  2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("Daikanwa"),
                  2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("Daikanwa"),
-                 build_string ("Morohashi's Daikanwa"),
-                 build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"),
-                 build_string ("Daikanwa"),
-                 Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0);
-  staticpro (&Vcharset_mojikyo);
-  Vcharset_mojikyo =
-    make_charset (LEADING_BYTE_MOJIKYO, Qmojikyo, 256, 3,
-                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
-                 build_string ("Mojikyo"),
-                 build_string ("Mojikyo"),
-                 build_string ("Konjaku-Mojikyo"),
-                 build_string (""),
-                 Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0);
-  staticpro (&Vcharset_mojikyo_2022_1);
-  Vcharset_mojikyo_2022_1 =
-    make_charset (LEADING_BYTE_MOJIKYO_2022_1, Qmojikyo_2022_1, 94, 3,
-                 2, 2, ':', CHARSET_LEFT_TO_RIGHT,
-                 build_string ("Mojikyo-2022-1"),
-                 build_string ("Mojikyo ISO-2022 Part 1"),
-                 build_string ("Konjaku-Mojikyo for ISO/IEC 2022 Part 1"),
-                 build_string (""),
-                 Qnil, 0, 0, 0, 33);
-
-#define DEF_MOJIKYO_PJ(n)                                                 \
-  staticpro (&Vcharset_mojikyo_pj_##n);                                           \
-  Vcharset_mojikyo_pj_##n =                                               \
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_##n, Qmojikyo_pj_##n, 94, 2,    \
-                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,                          \
-                 build_string ("Mojikyo-PJ-"#n),                          \
-                 build_string ("Mojikyo (pseudo JIS encoding) part "#n), \
-                 build_string                                             \
-                 ("Konjaku-Mojikyo (pseudo JIS encoding) part "#n),       \
-                 build_string                                             \
-                 ("\\(MojikyoPJ-"#n "\\|jisx0208\\.Mojikyo-"#n "\\)$"),   \
-                 Qnil, 0, 0, 0, 33);
-
-  DEF_MOJIKYO_PJ (1);
-  DEF_MOJIKYO_PJ (2);
-  DEF_MOJIKYO_PJ (3);
-  DEF_MOJIKYO_PJ (4);
-  DEF_MOJIKYO_PJ (5);
-  DEF_MOJIKYO_PJ (6);
-  DEF_MOJIKYO_PJ (7);
-  DEF_MOJIKYO_PJ (8);
-  DEF_MOJIKYO_PJ (9);
-  DEF_MOJIKYO_PJ (10);
-  DEF_MOJIKYO_PJ (11);
-  DEF_MOJIKYO_PJ (12);
-  DEF_MOJIKYO_PJ (13);
-  DEF_MOJIKYO_PJ (14);
-  DEF_MOJIKYO_PJ (15);
-  DEF_MOJIKYO_PJ (16);
-  DEF_MOJIKYO_PJ (17);
-  DEF_MOJIKYO_PJ (18);
-  DEF_MOJIKYO_PJ (19);
-  DEF_MOJIKYO_PJ (20);
-  DEF_MOJIKYO_PJ (21);
+                 build_string ("Morohashi's Daikanwa Rev.2"),
+                 build_string
+                 ("Daikanwa dictionary (second revised version)"),
+                 build_string ("Daikanwa\\(\\.[0-9]+\\)?-3"),
+                 Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA,
+                 MIN_CHAR_DAIKANWA, 0, Qnil, CONVERSION_IDENTICAL);
 
   staticpro (&Vcharset_ethiopic_ucs);
   Vcharset_ethiopic_ucs =
 
   staticpro (&Vcharset_ethiopic_ucs);
   Vcharset_ethiopic_ucs =
@@ -2876,7 +3055,8 @@ complex_vars_of_mule_charset (void)
                  build_string ("Ethiopic (UCS)"),
                  build_string ("Ethiopic of UCS"),
                  build_string ("Ethiopic-Unicode"),
                  build_string ("Ethiopic (UCS)"),
                  build_string ("Ethiopic of UCS"),
                  build_string ("Ethiopic-Unicode"),
-                 Qnil, 0x1200, 0x137F, 0x1200, 0);
+                 Qnil, 0x1200, 0x137F, 0, 0,
+                 Qnil, CONVERSION_IDENTICAL);
 #endif
   staticpro (&Vcharset_chinese_big5_1);
   Vcharset_chinese_big5_1 =
 #endif
   staticpro (&Vcharset_chinese_big5_1);
   Vcharset_chinese_big5_1 =
@@ -2887,7 +3067,7 @@ complex_vars_of_mule_charset (void)
                  build_string
                  ("Big5 Level-1 Chinese traditional"),
                  build_string ("big5"),
                  build_string
                  ("Big5 Level-1 Chinese traditional"),
                  build_string ("big5"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
   staticpro (&Vcharset_chinese_big5_2);
   Vcharset_chinese_big5_2 =
     make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
   staticpro (&Vcharset_chinese_big5_2);
   Vcharset_chinese_big5_2 =
     make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
@@ -2897,7 +3077,7 @@ complex_vars_of_mule_charset (void)
                  build_string
                  ("Big5 Level-2 Chinese traditional"),
                  build_string ("big5"),
                  build_string
                  ("Big5 Level-2 Chinese traditional"),
                  build_string ("big5"),
-                 Qnil, 0, 0, 0, 33);
+                 Qnil, 0, 0, 0, 33, Qnil, CONVERSION_IDENTICAL);
 
 #ifdef ENABLE_COMPOSITE_CHARS
   /* #### For simplicity, we put composite chars into a 96x96 charset.
 
 #ifdef ENABLE_COMPOSITE_CHARS
   /* #### For simplicity, we put composite chars into a 96x96 charset.