Add an EXFUN for `Ffind_char'.

[chise/xemacs-chise.git-] / src / mule-charset.c

diff --git a/src/mule-charset.c b/src/mule-charset.c
index 24a74c7..751fd32 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.
 

@@ -77,7 +77,7 @@ Lisp_Object Vcharset_latin_tcvn5712;
 Lisp_Object Vcharset_latin_viscii_lower;
 Lisp_Object Vcharset_latin_viscii_upper;
 Lisp_Object Vcharset_chinese_big5;
 Lisp_Object Vcharset_latin_viscii_lower;
 Lisp_Object Vcharset_latin_viscii_upper;
 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_1;
 Lisp_Object Vcharset_ideograph_hanziku_2;
 Lisp_Object Vcharset_ideograph_hanziku_3;

@@ -176,20 +176,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)

@@ -218,58 +204,6 @@ 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_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)

@@ -279,9 +213,6 @@ put_char_ccs_code_point (Lisp_Object character,
       || (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))

@@ -331,16 +262,10 @@ put_char_ccs_code_point (Lisp_Object character,
          Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
          if (INTP (cpos))
            {
          Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
          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_vector (ccs_len, Qnil);
-       }
-
-      decoding_table_put_char (v, dim, byte_offset, code_point, character);
+      decoding_table_put_char (ccs, code_point, character);

     }
   return value;
 }
     }
   return value;
 }

@@ -357,15 +282,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_TABLEP (encoding_table))
     {
        }
     }
   if (CHAR_TABLEP (encoding_table))
     {

-      put_char_id_table (XCHAR_TABLE(encoding_table), character, Qnil);
+      put_char_id_table (XCHAR_TABLE(encoding_table), character, Qunbound);

     }
   return Qt;
 }
     }
   return Qt;
 }

@@ -428,7 +350,7 @@ Lisp_Object Qascii,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
   Qchinese_big5,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
   Qchinese_big5,

-  Qchinese_big5_cdp,
+  /*  Qchinese_big5_cdp, */

   Qideograph_hanziku_1,
   Qideograph_hanziku_2,
   Qideograph_hanziku_3,
   Qideograph_hanziku_1,
   Qideograph_hanziku_2,
   Qideograph_hanziku_3,

@@ -895,7 +817,7 @@ 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_DECODING_TABLE(cs) = Qunbound;

   CHARSET_MIN_CODE     (cs) = min_code;
   CHARSET_MAX_CODE     (cs) = max_code;
   CHARSET_CODE_OFFSET  (cs) = code_offset;
   CHARSET_MIN_CODE     (cs) = min_code;
   CHARSET_MAX_CODE     (cs) = max_code;
   CHARSET_CODE_OFFSET  (cs) = code_offset;

@@ -984,12 +906,52 @@ 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);
+#ifdef HAVE_DATABASE
+  if (EQ (decoding_table, Qunloaded) ||
+      EQ (decoding_table, Qunbound) ||
+      NILP (decoding_table) )
+    {
+      char_id = load_char_decoding_entry_maybe (ccs, code_point);
+    }
+#endif
+  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)
 {
   Lisp_Object mother = XCHARSET_MOTHER (charset);
   int final;
 
 decode_builtin_char (Lisp_Object charset, int code_point)
 {
   Lisp_Object mother = XCHARSET_MOTHER (charset);
   int final;
 

-  if ( CHARSETP (mother) )
+  if ( CHARSETP (mother) && (XCHARSET_MAX_CODE (charset) > 0) )

     {
       int code = code_point;
 
     {
       int code = code_point;
 

@@ -1028,8 +990,10 @@ decode_builtin_char (Lisp_Object charset, int code_point)
              + (row - (18 + 32)) * 94
              + cell - 33;
        }
              + (row - (18 + 32)) * 94
              + cell - 33;
        }

-      return DECODE_CHAR (mother, code + XCHARSET_CODE_OFFSET(charset));
+      return
+       decode_builtin_char (mother, code + XCHARSET_CODE_OFFSET(charset));

     }
     }

+#if 0

   else if (EQ (charset, Vcharset_chinese_big5))
     {
       int c1 = code_point >> 8;
   else if (EQ (charset, Vcharset_chinese_big5))
     {
       int c1 = code_point >> 8;

@@ -1056,6 +1020,7 @@ decode_builtin_char (Lisp_Object charset, int code_point)
          code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
        }
     }
          code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
        }
     }

+#endif

   if ((final = XCHARSET_FINAL (charset)) >= '0')
     {
       if (XCHARSET_DIMENSION (charset) == 1)
   if ((final = XCHARSET_FINAL (charset)) >= '0')
     {
       if (XCHARSET_DIMENSION (charset) == 1)

@@ -1134,7 +1099,8 @@ charset_code_point (Lisp_Object charset, Emchar ch)
        code = charset_code_point (mother, ch);
       else
        code = ch;
        code = charset_code_point (mother, ch);
       else
        code = ch;

-      if ( (min <= code) && (code <= max) )
+      if ( ((max == 0) && CHARSETP (mother)) ||
+          ((min <= code) && (code <= max)) )

        {
          int d = code - XCHARSET_CODE_OFFSET (charset);
 
        {
          int d = code - XCHARSET_CODE_OFFSET (charset);
 

@@ -1493,6 +1459,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

@@ -1501,6 +1468,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

@@ -1525,6 +1493,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))
 {

@@ -2092,7 +2067,183 @@ Set mapping-table of CHARSET to TABLE.
     }
   return table;
 }
     }
   return table;
 }

+
+DEFUN ("save-charset-mapping-table", Fsave_charset_mapping_table, 1, 1, 0, /*
+Save mapping-table of CHARSET.
+*/
+       (charset))
+{
+#ifdef HAVE_DATABASE
+  struct Lisp_Charset *cs;
+  int byte_min, byte_max;
+  Lisp_Object db;
+  Lisp_Object db_file;
+
+  charset = Fget_charset (charset);
+  cs = XCHARSET (charset);
+
+  db_file = char_attribute_system_db_file (CHARSET_NAME (cs),
+                                          Qsystem_char_id, 1);
+  db = Fopen_database (db_file, Qnil, Qnil, build_string ("w+"), Qnil);
+
+  byte_min = CHARSET_BYTE_OFFSET (cs);
+  byte_max = byte_min + CHARSET_BYTE_SIZE (cs);
+  switch (CHARSET_DIMENSION (cs))
+    {
+    case 1:
+      {
+       Lisp_Object table_c = XCHARSET_DECODING_TABLE (charset);
+       int cell;
+
+       for (cell = byte_min; cell < byte_max; cell++)
+         {
+           Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
+
+           if (CHARP (c))
+             Fput_database (Fprin1_to_string (make_int (cell), Qnil),
+                            Fprin1_to_string (c, Qnil),
+                            db, Qt);
+         }
+      }
+      break;
+    case 2:
+      {
+       Lisp_Object table_r = XCHARSET_DECODING_TABLE (charset);
+       int row;
+
+       for (row = byte_min; row < byte_max; row++)
+         {
+           Lisp_Object table_c = get_ccs_octet_table (table_r, charset, row);
+           int cell;
+
+           for (cell = byte_min; cell < byte_max; cell++)
+             {
+               Lisp_Object c = get_ccs_octet_table (table_c, charset, cell);
+
+               if (CHARP (c))
+                 Fput_database (Fprin1_to_string (make_int ((row << 8)
+                                                            | cell),
+                                                  Qnil),
+                                Fprin1_to_string (c, Qnil),
+                                db, Qt);
+             }
+         }
+      }
+      break;
+    case 3:
+      {
+       Lisp_Object table_p = XCHARSET_DECODING_TABLE (charset);
+       int plane;
+
+       for (plane = byte_min; plane < byte_max; plane++)
+         {
+           Lisp_Object table_r
+             = get_ccs_octet_table (table_p, charset, plane);
+           int row;
+
+           for (row = byte_min; row < byte_max; row++)
+             {
+               Lisp_Object table_c
+                 = get_ccs_octet_table (table_r, charset, row);
+               int cell;
+
+               for (cell = byte_min; cell < byte_max; cell++)
+                 {
+                   Lisp_Object c = get_ccs_octet_table (table_c, charset,
+                                                        cell);
+
+                   if (CHARP (c))
+                     Fput_database (Fprin1_to_string (make_int ((plane << 16)
+                                                                | (row <<  8)
+                                                                | cell),
+                                                      Qnil),
+                                    Fprin1_to_string (c, Qnil),
+                                    db, Qt);
+                 }
+             }
+         }
+      }
+      break;
+    default:
+      {
+       Lisp_Object table_g = XCHARSET_DECODING_TABLE (charset);
+       int group;
+
+       for (group = byte_min; group < byte_max; group++)
+         {
+           Lisp_Object table_p
+             = get_ccs_octet_table (table_g, charset, group);
+           int plane;
+
+           for (plane = byte_min; plane < byte_max; plane++)
+             {
+               Lisp_Object table_r
+                 = get_ccs_octet_table (table_p, charset, plane);
+               int row;
+
+               for (row = byte_min; row < byte_max; row++)
+                 {
+                   Lisp_Object table_c
+                     = get_ccs_octet_table (table_r, charset, row);
+                   int cell;
+
+                   for (cell = byte_min; cell < byte_max; cell++)
+                     {
+                       Lisp_Object c
+                         = get_ccs_octet_table (table_c, charset, cell);
+
+                       if (CHARP (c))
+                         Fput_database (Fprin1_to_string
+                                        (make_int ((  group << 24)
+                                                   | (plane << 16)
+                                                   | (row   <<  8)
+                                                   |  cell),
+                                         Qnil),
+                                        Fprin1_to_string (c, Qnil),
+                                        db, Qt);
+                     }
+                 }
+             }
+         }
+      }
+    }
+  return Fclose_database (db);
+#else
+  return Qnil;

 #endif
 #endif

+}
+
+#ifdef HAVE_CHISE_CLIENT
+Emchar
+load_char_decoding_entry_maybe (Lisp_Object ccs, int code_point)
+{
+  Lisp_Object db;
+  Lisp_Object db_file
+    = char_attribute_system_db_file (XCHARSET_NAME(ccs), Qsystem_char_id,
+                                    0);
+
+  db = Fopen_database (db_file, Qnil, Qnil, build_string ("r"), Qnil);
+  if (!NILP (db))
+    {
+      Lisp_Object ret
+       = Fget_database (Fprin1_to_string (make_int (code_point), Qnil),
+                        db, Qnil);
+      if (!NILP (ret))
+       {
+         ret = Fread (ret);
+         if (CHARP (ret))
+           {
+             decoding_table_put_char (ccs, code_point, ret);
+             Fclose_database (db);
+             return XCHAR (ret);
+           }
+       }
+      Fclose_database (db);
+    }
+  return -1;
+}
+#endif /* HAVE_CHISE_CLIENT */
+#endif /* UTF2000 */

 
 \f
 /************************************************************************/
 
 \f
 /************************************************************************/

@@ -2117,7 +2268,7 @@ If corresponding character is not found, nil is returned.
   if (NILP (defined_only))
     c = DECODE_CHAR (charset, c);
   else
   if (NILP (defined_only))
     c = DECODE_CHAR (charset, c);
   else

-    c = DECODE_DEFINED_CHAR (charset, c);
+    c = decode_defined_char (charset, c);

   return c >= 0 ? make_char (c) : Qnil;
 }
 
   return c >= 0 ? make_char (c) : Qnil;
 }
 

@@ -2431,6 +2582,7 @@ syms_of_mule_charset (void)
   DEFSUBR (Fdecode_char);
   DEFSUBR (Fdecode_builtin_char);
   DEFSUBR (Fencode_char);
   DEFSUBR (Fdecode_char);
   DEFSUBR (Fdecode_builtin_char);
   DEFSUBR (Fencode_char);

+  DEFSUBR (Fsave_charset_mapping_table);

 #endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
 #endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);

@@ -2518,7 +2670,7 @@ syms_of_mule_charset (void)
   defsymbol (&Qideograph_daikanwa_2,   "ideograph-daikanwa-2");
   defsymbol (&Qideograph_daikanwa,     "ideograph-daikanwa");
   defsymbol (&Qchinese_big5,           "chinese-big5");
   defsymbol (&Qideograph_daikanwa_2,   "ideograph-daikanwa-2");
   defsymbol (&Qideograph_daikanwa,     "ideograph-daikanwa");
   defsymbol (&Qchinese_big5,           "chinese-big5");

-  defsymbol (&Qchinese_big5_cdp,       "chinese-big5-cdp");
+  /*  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_1,    "ideograph-hanziku-1");
   defsymbol (&Qideograph_hanziku_2,    "ideograph-hanziku-2");
   defsymbol (&Qideograph_hanziku_3,    "ideograph-hanziku-3");

@@ -2612,7 +2764,7 @@ 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, CONVERSION_IDENTICAL);
+                 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,
   staticpro (&Vcharset_ucs_bmp);
   Vcharset_ucs_bmp =
     make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,

@@ -2651,17 +2803,17 @@ complex_vars_of_mule_charset (void)
                  build_string ("UCS for CNS 11643"),
                  build_string ("ISO/IEC 10646 for CNS 11643"),
                  build_string (""),
                  build_string ("UCS for CNS 11643"),
                  build_string ("ISO/IEC 10646 for CNS 11643"),
                  build_string (""),

-                 Qnil, 0, 0, 0, 0,
-                 Qnil, CONVERSION_IDENTICAL);
+                 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,
                  2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  build_string ("UCS for JIS"),
                  build_string ("UCS for JIS X 0208, 0212 and 0213"),
   staticpro (&Vcharset_ucs_jis);
   Vcharset_ucs_jis =
     make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3,
                  2, 2, 0, CHARSET_LEFT_TO_RIGHT,
                  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, CONVERSION_IDENTICAL);
+                 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,
   staticpro (&Vcharset_ucs_ks);
   Vcharset_ucs_ks =
     make_charset (LEADING_BYTE_UCS_KS, Qucs_ks, 256, 3,

@@ -2670,7 +2822,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("UCS for CCS defined by KS"),
                  build_string ("ISO/IEC 10646 for Korean Standards"),
                  build_string (""),
                  build_string ("UCS for CCS defined by KS"),
                  build_string ("ISO/IEC 10646 for Korean Standards"),
                  build_string (""),

-                 Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+                 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,

@@ -2679,7 +2831,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("UCS for Big5"),
                  build_string ("ISO/IEC 10646 for Big5"),
                  build_string (""),
                  build_string ("UCS for Big5"),
                  build_string ("ISO/IEC 10646 for Big5"),
                  build_string (""),

-                 Qnil, 0, 0, 0, 0, Qnil, CONVERSION_IDENTICAL);
+                 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

@@ -2955,11 +3107,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"),
+                 build_string ("big5-0"),

                  Qnil,
                  Qnil,

-                 0 /* MIN_CHAR_BIG5_CDP */,
-                 0 /* MAX_CHAR_BIG5_CDP */, 0, 0,
-                 Qnil, CONVERSION_IDENTICAL);
+                 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,

@@ -2970,6 +3122,7 @@ complex_vars_of_mule_charset (void)
                  build_string ("big5\\.cdp-0"),
                  Qnil, MIN_CHAR_BIG5_CDP, MAX_CHAR_BIG5_CDP,
                  MIN_CHAR_BIG5_CDP, 0, Qnil, CONVERSION_IDENTICAL);
                  build_string ("big5\\.cdp-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 =                                     \
 #define DEF_HANZIKU(n)                                                 \
   staticpro (&Vcharset_ideograph_hanziku_##n);                         \
   Vcharset_ideograph_hanziku_##n =                                     \