X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=2db3cbcebfc59250dcea85a408b636e6f39276be;hb=975655e6b5b1526ee82b159b3eadf69888c42090;hp=aaeb8153dc1ac9e5a66092c2ac23dde983e3a0df;hpb=d7a34ff0ad82e43a5b18c155ab04272a01f78627;p=chise%2Fxemacs-chise.git-

diff --git a/src/mule-charset.c b/src/mule-charset.c
index aaeb815..2db3cbc 100644
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -1,6 +1,7 @@
 /* Functions to handle multilingual characters.
    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.
+   Copyright (C) 1999,2000 MORIOKA Tomohiko
 
 This file is part of XEmacs.
 
@@ -59,11 +60,14 @@ Lisp_Object Vcharset_japanese_jisx0212;
 Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;
 #ifdef UTF2000
+Lisp_Object Vcharset_ucs;
 Lisp_Object Vcharset_ucs_bmp;
 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_ideograph_daikanwa;
+Lisp_Object Vcharset_mojikyo;
 Lisp_Object Vcharset_mojikyo_pj_1;
 Lisp_Object Vcharset_mojikyo_pj_2;
 Lisp_Object Vcharset_mojikyo_pj_3;
@@ -107,7 +111,7 @@ static int composite_char_col_next;
 struct charset_lookup *chlook;
 
 static const struct lrecord_description charset_lookup_description_1[] = {
-  { XD_LISP_OBJECT, offsetof(struct charset_lookup, charset_by_leading_byte),
+  { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte),
 #ifdef UTF2000
     128+4*128
 #else
@@ -117,7 +121,7 @@ static const struct lrecord_description charset_lookup_description_1[] = {
 };
 
 static const struct struct_description charset_lookup_description = {
-  sizeof(struct charset_lookup),
+  sizeof (struct charset_lookup),
   charset_lookup_description_1
 };
 
@@ -156,9 +160,9 @@ const Bytecount rep_bytes_by_first_byte[0xA0] =
 #ifdef UTF2000
 
 static Lisp_Object
-mark_char_byte_table (Lisp_Object obj)
+mark_byte_table (Lisp_Object obj)
 {
-  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj);
+  Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
   int i;
 
   for (i = 0; i < 256; i++)
@@ -169,19 +173,19 @@ mark_char_byte_table (Lisp_Object obj)
 }
 
 static int
-char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
+byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-  struct Lisp_Char_Byte_Table *cte1 = XCHAR_BYTE_TABLE (obj1);
-  struct Lisp_Char_Byte_Table *cte2 = XCHAR_BYTE_TABLE (obj2);
+  Lisp_Byte_Table *cte1 = XBYTE_TABLE (obj1);
+  Lisp_Byte_Table *cte2 = XBYTE_TABLE (obj2);
   int i;
 
   for (i = 0; i < 256; i++)
-    if (CHAR_BYTE_TABLE_P (cte1->property[i]))
+    if (BYTE_TABLE_P (cte1->property[i]))
       {
-	if (CHAR_BYTE_TABLE_P (cte2->property[i]))
+	if (BYTE_TABLE_P (cte2->property[i]))
 	  {
-	    if (!char_byte_table_equal (cte1->property[i],
-					cte2->property[i], depth + 1))
+	    if (!byte_table_equal (cte1->property[i],
+				   cte2->property[i], depth + 1))
 	      return 0;
 	  }
 	else
@@ -194,224 +198,236 @@ char_byte_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 }
 
 static unsigned long
-char_byte_table_hash (Lisp_Object obj, int depth)
+byte_table_hash (Lisp_Object obj, int depth)
 {
-  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj);
+  Lisp_Byte_Table *cte = XBYTE_TABLE (obj);
 
   return internal_array_hash (cte->property, 256, depth);
 }
 
-static const struct lrecord_description char_byte_table_description[] = {
-  { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Byte_Table, property), 256 },
+static const struct lrecord_description byte_table_description[] = {
+  { XD_LISP_OBJECT_ARRAY, offsetof(Lisp_Byte_Table, property), 256 },
   { XD_END }
 };
 
-DEFINE_LRECORD_IMPLEMENTATION ("char-byte-table", char_byte_table,
-                               mark_char_byte_table,
+DEFINE_LRECORD_IMPLEMENTATION ("byte-table", byte_table,
+                               mark_byte_table,
 			       internal_object_printer,
-			       0, char_byte_table_equal,
-			       char_byte_table_hash,
-			       char_byte_table_description,
-			       struct Lisp_Char_Byte_Table);
+			       0, byte_table_equal,
+			       byte_table_hash,
+			       byte_table_description,
+			       Lisp_Byte_Table);
 
 static Lisp_Object
-make_char_byte_table (Lisp_Object initval)
+make_byte_table (Lisp_Object initval, int older)
 {
   Lisp_Object obj;
   int i;
-  struct Lisp_Char_Byte_Table *cte =
-    alloc_lcrecord_type (struct Lisp_Char_Byte_Table,
-			 &lrecord_char_byte_table);
+  Lisp_Byte_Table *cte;
+
+  if (older)
+    cte = alloc_older_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
+  else
+    cte = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
 
   for (i = 0; i < 256; i++)
     cte->property[i] = initval;
 
-  XSETCHAR_BYTE_TABLE (obj, cte);
+  XSETBYTE_TABLE (obj, cte);
   return obj;
 }
 
 static Lisp_Object
-copy_char_byte_table (Lisp_Object entry)
+copy_byte_table (Lisp_Object entry)
 {
-  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (entry);
+  Lisp_Byte_Table *cte = XBYTE_TABLE (entry);
   Lisp_Object obj;
   int i;
-  struct Lisp_Char_Byte_Table *ctenew =
-    alloc_lcrecord_type (struct Lisp_Char_Byte_Table,
-			 &lrecord_char_byte_table);
+  Lisp_Byte_Table *ctenew
+    = alloc_lcrecord_type (Lisp_Byte_Table, &lrecord_byte_table);
 
   for (i = 0; i < 256; i++)
     {
       Lisp_Object new = cte->property[i];
-      if (CHAR_BYTE_TABLE_P (new))
-	ctenew->property[i] = copy_char_byte_table (new);
+      if (BYTE_TABLE_P (new))
+	ctenew->property[i] = copy_byte_table (new);
       else
 	ctenew->property[i] = new;
     }
 
-  XSETCHAR_BYTE_TABLE (obj, ctenew);
+  XSETBYTE_TABLE (obj, ctenew);
   return obj;
 }
 
 
 static Lisp_Object
-mark_char_code_table (Lisp_Object obj)
+mark_char_id_table (Lisp_Object obj)
 {
-  struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj);
+  Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
 
   return cte->table;
 }
 
 static int
-char_code_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
+char_id_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-  struct Lisp_Char_Code_Table *cte1 = XCHAR_CODE_TABLE (obj1);
-  struct Lisp_Char_Code_Table *cte2 = XCHAR_CODE_TABLE (obj2);
+  Lisp_Char_ID_Table *cte1 = XCHAR_ID_TABLE (obj1);
+  Lisp_Char_ID_Table *cte2 = XCHAR_ID_TABLE (obj2);
 
-  return char_byte_table_equal (cte1->table, cte2->table, depth + 1);
+  return byte_table_equal (cte1->table, cte2->table, depth + 1);
 }
 
 static unsigned long
-char_code_table_hash (Lisp_Object obj, int depth)
+char_id_table_hash (Lisp_Object obj, int depth)
 {
-  struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (obj);
+  Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (obj);
 
-  return char_code_table_hash (cte->table, depth + 1);
+  return char_id_table_hash (cte->table, depth + 1);
 }
 
-static const struct lrecord_description char_code_table_description[] = {
-  { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Code_Table, table), 1 },
+static const struct lrecord_description char_id_table_description[] = {
+  { XD_LISP_OBJECT, offsetof(Lisp_Char_ID_Table, table) },
   { XD_END }
 };
 
-DEFINE_LRECORD_IMPLEMENTATION ("char-code-table", char_code_table,
-                               mark_char_code_table,
+DEFINE_LRECORD_IMPLEMENTATION ("char-id-table", char_id_table,
+                               mark_char_id_table,
 			       internal_object_printer,
-			       0, char_code_table_equal,
-			       char_code_table_hash,
-			       char_code_table_description,
-			       struct Lisp_Char_Code_Table);
+			       0, char_id_table_equal,
+			       char_id_table_hash,
+			       char_id_table_description,
+			       Lisp_Char_ID_Table);
 
 static Lisp_Object
-make_char_code_table (Lisp_Object initval)
+make_char_id_table (Lisp_Object initval, int older)
 {
   Lisp_Object obj;
-  struct Lisp_Char_Code_Table *cte =
-    alloc_lcrecord_type (struct Lisp_Char_Code_Table,
-			 &lrecord_char_code_table);
+  Lisp_Char_ID_Table *cte;
+
+  if (older)
+    cte = alloc_older_lcrecord_type (Lisp_Char_ID_Table,
+				     &lrecord_char_id_table);
+  else
+    cte = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
 
-  cte->table = make_char_byte_table (initval);
+  cte->table = make_byte_table (initval, older);
 
-  XSETCHAR_CODE_TABLE (obj, cte);
+  XSETCHAR_ID_TABLE (obj, cte);
   return obj;
 }
 
+/* not used */
+#if 0
 static Lisp_Object
-copy_char_code_table (Lisp_Object entry)
+copy_char_id_table (Lisp_Object entry)
 {
-  struct Lisp_Char_Code_Table *cte = XCHAR_CODE_TABLE (entry);
+  Lisp_Char_ID_Table *cte = XCHAR_ID_TABLE (entry);
   Lisp_Object obj;
-  struct Lisp_Char_Code_Table *ctenew =
-    alloc_lcrecord_type (struct Lisp_Char_Code_Table,
-			 &lrecord_char_code_table);
+  Lisp_Char_ID_Table *ctenew
+    = alloc_lcrecord_type (Lisp_Char_ID_Table, &lrecord_char_id_table);
 
-  ctenew->table = copy_char_byte_table (cte->table);
-  XSETCHAR_CODE_TABLE (obj, ctenew);
+  ctenew->table = copy_byte_table (cte->table);
+  XSETCHAR_ID_TABLE (obj, ctenew);
   return obj;
 }
+#endif
 
 
 Lisp_Object
-get_char_code_table (Emchar ch, Lisp_Object table)
+get_char_id_table (Emchar ch, Lisp_Object table)
 {
   unsigned int code = ch;
-  struct Lisp_Char_Byte_Table* cpt
-    = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table);
+  Lisp_Byte_Table* cpt
+    = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
   Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)];
 
-  if (CHAR_BYTE_TABLE_P (ret))
-    cpt = XCHAR_BYTE_TABLE (ret);
+  if (BYTE_TABLE_P (ret))
+    cpt = XBYTE_TABLE (ret);
   else
     return ret;
 
   ret = cpt->property [(unsigned char) (code >> 16)];
-  if (CHAR_BYTE_TABLE_P (ret))
-    cpt = XCHAR_BYTE_TABLE (ret);
+  if (BYTE_TABLE_P (ret))
+    cpt = XBYTE_TABLE (ret);
   else
     return ret;
 
   ret = cpt->property [(unsigned char) (code >> 8)];
-  if (CHAR_BYTE_TABLE_P (ret))
-    cpt = XCHAR_BYTE_TABLE (ret);
+  if (BYTE_TABLE_P (ret))
+    cpt = XBYTE_TABLE (ret);
   else
     return ret;
   
   return cpt->property [(unsigned char) code];
 }
 
+void put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table);
 void
-put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table)
+put_char_id_table (Emchar ch, Lisp_Object value, Lisp_Object table)
 {
   unsigned int code = ch;
-  struct Lisp_Char_Byte_Table* cpt1
-    = XCHAR_BYTE_TABLE (XCHAR_CODE_TABLE (table)->table);
+  Lisp_Byte_Table* cpt1 = XBYTE_TABLE (XCHAR_ID_TABLE (table)->table);
   Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)];
 
-  if (CHAR_BYTE_TABLE_P (ret))
+  if (BYTE_TABLE_P (ret))
     {
-      struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret);
+      Lisp_Byte_Table* cpt2 = XBYTE_TABLE (ret);
       
       ret = cpt2->property[(unsigned char)(code >> 16)];
-      if (CHAR_BYTE_TABLE_P (ret))
+      if (BYTE_TABLE_P (ret))
 	{
-	  struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret);
+	  Lisp_Byte_Table* cpt3 = XBYTE_TABLE (ret);
 	  
 	  ret = cpt3->property[(unsigned char)(code >> 8)];
-	  if (CHAR_BYTE_TABLE_P (ret))
+	  if (BYTE_TABLE_P (ret))
 	    {
-	      struct Lisp_Char_Byte_Table* cpt4
-		= XCHAR_BYTE_TABLE (ret);
+	      Lisp_Byte_Table* cpt4 = XBYTE_TABLE (ret);
 	      
 	      cpt4->property[(unsigned char)code] = value;
 	    }
 	  else if (!EQ (ret, value))
 	    {
-	      Lisp_Object cpt4 = make_char_byte_table (ret);
-	      
-	      XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
+	      Lisp_Object cpt4
+		= make_byte_table (ret, OLDER_RECORD_P (table));
+
+	      XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
 	      cpt3->property[(unsigned char)(code >> 8)] = cpt4;
 	    }
 	}
       else if (!EQ (ret, value))
 	{
-	  Lisp_Object cpt3 = make_char_byte_table (ret);
-	  Lisp_Object cpt4 = make_char_byte_table (ret);
-	  
-	  XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
-	  XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)]
+	  int older = OLDER_RECORD_P (table);
+	  Lisp_Object cpt3 = make_byte_table (ret, older);
+	  Lisp_Object cpt4 = make_byte_table (ret, older);
+
+	  XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
+	  XBYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)]
 	    = cpt4;
 	  cpt2->property[(unsigned char)(code >> 16)] = cpt3;
 	}
     }
   else if (!EQ (ret, value))
     {
-      Lisp_Object cpt2 = make_char_byte_table (ret);
-      Lisp_Object cpt3 = make_char_byte_table (ret);
-      Lisp_Object cpt4 = make_char_byte_table (ret);
-      
-      XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
-      XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >>  8)] = cpt4;
-      XCHAR_BYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3;
+      int older = OLDER_RECORD_P (table);
+      Lisp_Object cpt2 = make_byte_table (ret, older);
+      Lisp_Object cpt3 = make_byte_table (ret, older);
+      Lisp_Object cpt4 = make_byte_table (ret, older);
+
+      XBYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
+      XBYTE_TABLE(cpt3)->property[(unsigned char)(code >>  8)] = cpt4;
+      XBYTE_TABLE(cpt2)->property[(unsigned char)(code >> 16)] = cpt3;
       cpt1->property[(unsigned char)(code >> 24)] = cpt2;
     }
 }
 
 
-Lisp_Object Vcharacter_attribute_table;
+Lisp_Object Vchar_attribute_hash_table;
 Lisp_Object Vcharacter_composition_table;
 Lisp_Object Vcharacter_variant_table;
 
+Lisp_Object Qideograph_daikanwa;
 Lisp_Object Q_decomposition;
+Lisp_Object Qucs;
 Lisp_Object Q_ucs;
 Lisp_Object Qcompat;
 Lisp_Object Qisolated;
@@ -430,8 +446,14 @@ Lisp_Object Qnarrow;
 Lisp_Object Qsmall;
 Lisp_Object Qfont;
 
+Emchar to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg);
+
+Lisp_Object put_char_ccs_code_point (Lisp_Object character,
+				     Lisp_Object ccs, Lisp_Object value);
+Lisp_Object remove_char_ccs (Lisp_Object character, Lisp_Object ccs);
+
 Emchar
-to_char_code (Lisp_Object v, char* err_msg, Lisp_Object err_arg)
+to_char_id (Lisp_Object v, char* err_msg, Lisp_Object err_arg)
 {
   if (INTP (v))
     return XINT (v);
@@ -485,21 +507,21 @@ Return character corresponding with list.
     {
       Lisp_Object v = Fcar (rest);
       Lisp_Object ret;
-      Emchar c = to_char_code (v, "Invalid value for composition", list);
+      Emchar c = to_char_id (v, "Invalid value for composition", list);
 
-      ret = get_char_code_table (c, table);
+      ret = get_char_id_table (c, table);
 
       rest = Fcdr (rest);
       if (NILP (rest))
 	{
-	  if (!CHAR_CODE_TABLE_P (ret))
+	  if (!CHAR_ID_TABLE_P (ret))
 	    return ret;
 	  else
 	    return Qt;
 	}
       else if (!CONSP (rest))
 	break;
-      else if (CHAR_CODE_TABLE_P (ret))
+      else if (CHAR_ID_TABLE_P (ret))
 	table = ret;
       else
 	signal_simple_error ("Invalid table is found with", list);
@@ -513,8 +535,79 @@ Return variants of CHARACTER.
        (character))
 {
   CHECK_CHAR (character);
-  return Fcopy_list (get_char_code_table (XCHAR (character),
-					  Vcharacter_variant_table));
+  return Fcopy_list (get_char_id_table (XCHAR (character),
+					Vcharacter_variant_table));
+}
+
+
+/* We store the char-attributes in hash tables with the names as the
+   key and the actual char-id-table object as the value.  Occasionally
+   we need to use them in a list format.  These routines provide us
+   with that. */
+struct char_attribute_list_closure
+{
+  Lisp_Object *char_attribute_list;
+};
+
+static int
+add_char_attribute_to_list_mapper (Lisp_Object key, Lisp_Object value,
+				   void *char_attribute_list_closure)
+{
+  /* This function can GC */
+  struct char_attribute_list_closure *calcl
+    = (struct char_attribute_list_closure*) char_attribute_list_closure;
+  Lisp_Object *char_attribute_list = calcl->char_attribute_list;
+
+  *char_attribute_list = Fcons (key, *char_attribute_list);
+  return 0;
+}
+
+DEFUN ("char-attribute-list", Fchar_attribute_list, 0, 0, 0, /*
+Return the list of all existing character attributes except coded-charsets.
+*/
+       ())
+{
+  Lisp_Object char_attribute_list = Qnil;
+  struct gcpro gcpro1;
+  struct char_attribute_list_closure char_attribute_list_closure;
+  
+  GCPRO1 (char_attribute_list);
+  char_attribute_list_closure.char_attribute_list = &char_attribute_list;
+  elisp_maphash (add_char_attribute_to_list_mapper,
+		 Vchar_attribute_hash_table,
+		 &char_attribute_list_closure);
+  UNGCPRO;
+  return char_attribute_list;
+}
+
+
+/* We store the char-id-tables in hash tables with the attributes as
+   the key and the actual char-id-table object as the value.  Each
+   char-id-table stores values of an attribute corresponding with
+   characters.  Occasionally we need to get attributes of a character
+   in a association-list format.  These routines provide us with
+   that. */
+struct char_attribute_alist_closure
+{
+  Emchar char_id;
+  Lisp_Object *char_attribute_alist;
+};
+
+static int
+add_char_attribute_alist_mapper (Lisp_Object key, Lisp_Object value,
+				 void *char_attribute_alist_closure)
+{
+  /* This function can GC */
+  struct char_attribute_alist_closure *caacl =
+    (struct char_attribute_alist_closure*) char_attribute_alist_closure;
+  Lisp_Object ret = get_char_id_table (caacl->char_id, value);
+  if (!UNBOUNDP (ret))
+    {
+      Lisp_Object *char_attribute_alist = caacl->char_attribute_alist;
+      *char_attribute_alist
+	= Fcons (Fcons (key, ret), *char_attribute_alist);
+    }
+  return 0;
 }
 
 DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
@@ -522,9 +615,41 @@ Return the alist of attributes of CHARACTER.
 */
        (character))
 {
+  Lisp_Object alist = Qnil;
+  int i;
+
   CHECK_CHAR (character);
-  return Fcopy_alist (get_char_code_table (XCHAR (character),
-					   Vcharacter_attribute_table));
+  {
+    struct gcpro gcpro1;
+    struct char_attribute_alist_closure char_attribute_alist_closure;
+  
+    GCPRO1 (alist);
+    char_attribute_alist_closure.char_id = XCHAR (character);
+    char_attribute_alist_closure.char_attribute_alist = &alist;
+    elisp_maphash (add_char_attribute_alist_mapper,
+		   Vchar_attribute_hash_table,
+		   &char_attribute_alist_closure);
+    UNGCPRO;
+  }
+
+  for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
+    {
+      Lisp_Object ccs = chlook->charset_by_leading_byte[i];
+
+      if (!NILP (ccs))
+	{
+	  Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
+	  Lisp_Object cpos;
+
+	  if ( CHAR_ID_TABLE_P (encoding_table)
+	       && INTP (cpos = get_char_id_table (XCHAR (character),
+						  encoding_table)) )
+	    {
+	      alist = Fcons (Fcons (ccs, cpos), alist);
+	    }
+	}
+    }
+  return alist;
 }
 
 DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
@@ -532,44 +657,33 @@ Return the value of CHARACTER's ATTRIBUTE.
 */
        (character, attribute))
 {
-  Lisp_Object ret;
   Lisp_Object ccs;
 
   CHECK_CHAR (character);
-  ret = get_char_code_table (XCHAR (character),
-			     Vcharacter_attribute_table);
-  if (EQ (ret, Qnil))
-    return Qnil;
-
   if (!NILP (ccs = Ffind_charset (attribute)))
-    attribute = ccs;
-
-  return Fcdr (Fassq (attribute, ret));
-}
-
-Lisp_Object
-put_char_attribute (Lisp_Object character, Lisp_Object attribute,
-		    Lisp_Object value)
-{
-  Emchar char_code = XCHAR (character);
-  Lisp_Object ret
-    = get_char_code_table (char_code, Vcharacter_attribute_table);
-  Lisp_Object cell;
-
-  cell = Fassq (attribute, ret);
-
-  if (NILP (cell))
     {
-      ret = Fcons (Fcons (attribute, value), ret);
+      Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
+
+      if (CHAR_ID_TABLE_P (encoding_table))
+	return get_char_id_table (XCHAR (character), encoding_table);
+      else
+	return Qnil;
     }
-  else if (!EQ (Fcdr (cell), value))
+  else
     {
-      Fsetcdr (cell, value);
+      Lisp_Object table = Fgethash (attribute,
+				    Vchar_attribute_hash_table,
+				    Qunbound);
+      if (!UNBOUNDP (table))
+	{
+	  Lisp_Object ret = get_char_id_table (XCHAR (character), table);
+	  if (!UNBOUNDP (ret))
+	    return ret;
+	}
     }
-  put_char_code_table (char_code, ret, Vcharacter_attribute_table);
-  return ret;
+  return Qnil;
 }
-  
+
 DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /*
 Store CHARACTER's ATTRIBUTE with VALUE.
 */
@@ -581,141 +695,338 @@ Store CHARACTER's ATTRIBUTE with VALUE.
   ccs = Ffind_charset (attribute);
   if (!NILP (ccs))
     {
-      Lisp_Object rest;
-      Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
-      Lisp_Object nv;
-      int i = -1;
-      int ccs_len;
+      return put_char_ccs_code_point (character, ccs, value);
+    }
+  else if (EQ (attribute, Q_decomposition))
+    {
+      Lisp_Object seq;
 
-      /* ad-hoc method for `ascii' */
-      if ((XCHARSET_CHARS (ccs) == 94) &&
-	  (XCHARSET_BYTE_OFFSET (ccs) != 33))
-	ccs_len = 128 - XCHARSET_BYTE_OFFSET (ccs);
-      else
-	ccs_len = XCHARSET_CHARS (ccs);
-	  
       if (!CONSP (value))
-	signal_simple_error ("Invalid value for coded-charset",
+	signal_simple_error ("Invalid value for ->decomposition",
 			     value);
 
-      attribute = ccs;
-      rest = Fget_char_attribute (character, attribute);
-      if (VECTORP (v))
+      if (CONSP (Fcdr (value)))
 	{
-	  if (!NILP (rest))
+	  Lisp_Object rest = value;
+	  Lisp_Object table = Vcharacter_composition_table;
+	  size_t len;
+	  int i = 0;
+
+	  GET_EXTERNAL_LIST_LENGTH (rest, len);
+	  seq = make_vector (len, Qnil);
+
+	  while (CONSP (rest))
 	    {
-	      while (!NILP (rest))
+	      Lisp_Object v = Fcar (rest);
+	      Lisp_Object ntable;
+	      Emchar c
+		= to_char_id (v, "Invalid value for ->decomposition", value);
+
+	      if (c < 0)
+		XVECTOR_DATA(seq)[i++] = v;
+	      else
+		XVECTOR_DATA(seq)[i++] = make_char (c);
+	      rest = Fcdr (rest);
+	      if (!CONSP (rest))
+		{
+		  put_char_id_table (c, character, table);
+		  break;
+		}
+	      else
 		{
-		  Lisp_Object ei = Fcar (rest);
-		  
-		  i = XINT (ei) - XCHARSET_BYTE_OFFSET (ccs);
-		  nv = XVECTOR_DATA(v)[i];
-		  if (!VECTORP (nv))
-		    break;
-		  v = nv;
-		  rest = Fcdr (rest);
+		  ntable = get_char_id_table (c, table);
+		  if (!CHAR_ID_TABLE_P (ntable))
+		    {
+		      ntable
+			= make_char_id_table (Qnil, OLDER_RECORD_P (table));
+		      put_char_id_table (c, ntable, table);
+		    }
+		  table = ntable;
 		}
-	      if (i >= 0)
-		XVECTOR_DATA(v)[i] = Qnil;
-	      v = XCHARSET_DECODING_TABLE (ccs);
 	    }
 	}
       else
 	{
-	  XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil);
-	}
+	  Lisp_Object v = Fcar (value);
 
-      if (XCHARSET_GRAPHIC (ccs) == 1)
-	value = Fcopy_list (value);
-      rest = value;
-      i = -1;
-      while (CONSP (rest))
-	{
-	  Lisp_Object ei = Fcar (rest);
-	  
-	  if (!INTP (ei))
-	    signal_simple_error ("Invalid value for coded-charset", value);
-	  i = XINT (ei);
-	  if ((i < 0) || (255 < i))
-	    signal_simple_error ("Invalid value for coded-charset", value);
-	  if (XCHARSET_GRAPHIC (ccs) == 1)
-	    {
-	      i &= 0x7F;
-	      Fsetcar (rest, make_int (i));
-	    }
-	  i -= XCHARSET_BYTE_OFFSET (ccs);
-	  nv = XVECTOR_DATA(v)[i];
-	  rest = Fcdr (rest);
-	  if (CONSP (rest))
+	  if (INTP (v))
 	    {
-	      if (!VECTORP (nv))
+	      Emchar c = XINT (v);
+	      Lisp_Object ret
+		= get_char_id_table (c, Vcharacter_variant_table);
+
+	      if (NILP (Fmemq (v, ret)))
 		{
-		  nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil));
+		  put_char_id_table (c, Fcons (character, ret),
+				     Vcharacter_variant_table);
 		}
-	      v = nv;
 	    }
-	  else
-	    break;
+	  seq = make_vector (1, v);
 	}
-      XVECTOR_DATA(v)[i] = character;
+      value = seq;
     }
-  else if (EQ (attribute, Q_decomposition))
+  else if (EQ (attribute, Q_ucs))
     {
-      Lisp_Object rest = value;
-      Lisp_Object table = Vcharacter_composition_table;
+      Lisp_Object ret;
+      Emchar c;
 
-      if (!CONSP (value))
-	signal_simple_error ("Invalid value for ->decomposition",
-			     value);
+      if (!INTP (value))
+	signal_simple_error ("Invalid value for ->ucs", value);
 
-      while (CONSP (rest))
+      c = XINT (value);
+
+      ret = get_char_id_table (c, Vcharacter_variant_table);
+      if (NILP (Fmemq (character, ret)))
 	{
-	  Lisp_Object v = Fcar (rest);
-	  Lisp_Object ntable;
-	  Emchar c
-	    = to_char_code (v, "Invalid value for ->decomposition", value);
+	  put_char_id_table (c, Fcons (character, ret),
+			     Vcharacter_variant_table);
+	}
+    }
+  {
+    Lisp_Object table = Fgethash (attribute,
+				  Vchar_attribute_hash_table,
+				  Qnil);
 
-	  rest = Fcdr (rest);
-	  if (!CONSP (rest))
+    if (NILP (table))
+      {
+	table = make_char_id_table (Qunbound, 0);
+	Fputhash (attribute, table, Vchar_attribute_hash_table);
+      }
+    put_char_id_table (XCHAR (character), value, table);
+    return value;
+  }
+}
+  
+DEFUN ("remove-char-attribute", Fremove_char_attribute, 2, 2, 0, /*
+Remove CHARACTER's ATTRIBUTE.
+*/
+       (character, attribute))
+{
+  Lisp_Object ccs;
+
+  CHECK_CHAR (character);
+  ccs = Ffind_charset (attribute);
+  if (!NILP (ccs))
+    {
+      return remove_char_ccs (character, ccs);
+    }
+  else
+    {
+      Lisp_Object table = Fgethash (attribute,
+				    Vchar_attribute_hash_table,
+				    Qunbound);
+      if (!UNBOUNDP (table))
+	{
+	  put_char_id_table (XCHAR (character), Qunbound, table);
+	  return Qt;
+	}
+    }
+  return Qnil;
+}
+
+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 i;
+
+  if (XVECTOR_LENGTH (v) > ccs_len)
+    return -1;
+
+  for (i = 0; i < XVECTOR_LENGTH (v); i++)
+    {
+      Lisp_Object c = XVECTOR_DATA(v)[i];
+
+      if (!NILP (c) && !CHARP (c))
+	{
+	  if (VECTORP (c))
 	    {
-	      put_char_code_table (c, character, table);
-	      break;
+	      int ret = decoding_table_check_elements (c, dim - 1, ccs_len);
+	      if (ret)
+		return ret;
 	    }
 	  else
+	    return -2;
+	}
+    }
+  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 encoding_table;
+
+  if (!EQ (XCHARSET_NAME (ccs), Qucs)
+      || (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))
+	{ /* obsolete representation: value must be a list of bytes */
+	  Lisp_Object ret = Fcar (value);
+	  Lisp_Object rest;
+
+	  if (!INTP (ret))
+	    signal_simple_error ("Invalid value for coded-charset", value);
+	  code_point = XINT (ret);
+	  if (XCHARSET_GRAPHIC (ccs) == 1)
+	    code_point &= 0x7F;
+	  rest = Fcdr (value);
+	  while (!NILP (rest))
 	    {
-	      ntable = get_char_code_table (c, table);
-	      if (!CHAR_CODE_TABLE_P (ntable))
-		{
-		  ntable = make_char_code_table (Qnil);
-		  put_char_code_table (c, ntable, table);
-		}
-	      table = ntable;
+	      int j;
+
+	      if (!CONSP (rest))
+		signal_simple_error ("Invalid value for coded-charset",
+				     value);
+	      ret = Fcar (rest);
+	      if (!INTP (ret))
+		signal_simple_error ("Invalid value for coded-charset",
+				     value);
+	      j = XINT (ret);
+	      if (XCHARSET_GRAPHIC (ccs) == 1)
+		j &= 0x7F;
+	      code_point = (code_point << 8) | j;
+	      rest = Fcdr (rest);
 	    }
+	  value = make_int (code_point);
 	}
+      else if (INTP (value))
+	{
+	  code_point = XINT (value);
+	  if (XCHARSET_GRAPHIC (ccs) == 1)
+	    {
+	      code_point &= 0x7F7F7F7F;
+	      value = make_int (code_point);
+	    }
+	}
+      else
+	signal_simple_error ("Invalid value for coded-charset", value);
+
+      if (VECTORP (v))
+	{
+	  Lisp_Object cpos = Fget_char_attribute (character, ccs);
+	  if (!NILP (cpos))
+	    {
+	      decoding_table_remove_char (v, dim, byte_offset, 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);
     }
-  else if (EQ (attribute, Q_ucs))
+  if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
     {
-      Lisp_Object ret;
-      Emchar c;
+      XCHARSET_ENCODING_TABLE (ccs)
+	= encoding_table = make_char_id_table (Qnil, -1);
+    }
+  put_char_id_table (XCHAR (character), value, encoding_table);
+  return Qt;
+}
 
-      if (!INTP (value))
-	signal_simple_error ("Invalid value for ->ucs", value);
+Lisp_Object
+remove_char_ccs (Lisp_Object character, Lisp_Object ccs)
+{
+  Lisp_Object decoding_table = XCHARSET_DECODING_TABLE (ccs);
+  Lisp_Object encoding_table = XCHARSET_ENCODING_TABLE (ccs);
 
-      c = XINT (value);
+  if (VECTORP (decoding_table))
+    {
+      Lisp_Object cpos = Fget_char_attribute (character, ccs);
 
-      ret = get_char_code_table (c, Vcharacter_variant_table);
-      if (NILP (Fmemq (character, ret)))
+      if (!NILP (cpos))
 	{
-	  put_char_code_table (c, Fcons (character, ret),
-			       Vcharacter_variant_table);
+	  decoding_table_remove_char (decoding_table,
+				      XCHARSET_DIMENSION (ccs),
+				      XCHARSET_BYTE_OFFSET (ccs),
+				      XINT (cpos));
 	}
     }
-  return put_char_attribute (character, attribute, value);
+  if (CHAR_ID_TABLE_P (encoding_table))
+    {
+      put_char_id_table (XCHAR (character), Qnil, encoding_table);
+    }
+  return Qt;
 }
 
-Lisp_Object Qucs;
-
 EXFUN (Fmake_char, 3);
+EXFUN (Fdecode_char, 2);
 
 DEFUN ("define-char", Fdefine_char, 1, 1, 0, /*
 Store character's ATTRIBUTES.
@@ -725,6 +1036,9 @@ Store character's ATTRIBUTES.
   Lisp_Object rest = attributes;
   Lisp_Object code = Fcdr (Fassq (Qucs, attributes));
   Lisp_Object character;
+#if 0
+  Lisp_Object daikanwa = Qnil;
+#endif
 
   if (NILP (code))
     {
@@ -735,11 +1049,15 @@ Store character's ATTRIBUTES.
 
 	  if (!LISTP (cell))
 	    signal_simple_error ("Invalid argument", attributes);
-	  if (!NILP (ccs = Ffind_charset (Fcar (cell))))
+	  if (!NILP (ccs = Ffind_charset (Fcar (cell)))
+	      && ((XCHARSET_FINAL (ccs) != 0) ||
+		  (XCHARSET_UCS_MAX (ccs) > 0)) )
 	    {
 	      cell = Fcdr (cell);
-	      character = Fmake_char (ccs, Fcar (cell),
-				      Fcar (Fcdr (cell)));
+	      if (CONSP (cell))
+		character = Fmake_char (ccs, Fcar (cell), Fcar (Fcdr (cell)));
+	      else
+		character = Fdecode_char (ccs, cell);
 	      goto setup_attributes;
 	    }
 	  rest = Fcdr (rest);
@@ -764,14 +1082,39 @@ Store character's ATTRIBUTES.
   while (CONSP (rest))
     {
       Lisp_Object cell = Fcar (rest);
+#if 0
+      Lisp_Object key = Fcar (cell);
+      Lisp_Object value = Fcdr (cell);
+#endif
 
       if (!LISTP (cell))
 	signal_simple_error ("Invalid argument", attributes);
+
+#if 0
+      if (EQ (key, Qmorohashi_daikanwa))
+	{
+	  size_t len;
+	  GET_EXTERNAL_LIST_LENGTH (value, len);
+
+	  if (len == 1)
+	    {
+	      if (NILP (daikanwa))
+		daikanwa = Fcdr (Fassq (Qideograph_daikanwa, rest));
+	      if (EQ (Fcar (value), daikanwa))
+		goto ignored;
+	    }
+	}
+      else if (EQ (key, Qideograph_daikanwa))
+	daikanwa = value;
+#endif
+
       Fput_char_attribute (character, Fcar (cell), Fcdr (cell));
+#if 0
+    ignored:
+#endif
       rest = Fcdr (rest);
     }
-  return
-    get_char_code_table (XCHAR (character), Vcharacter_attribute_table);
+  return character;
 }
 
 Lisp_Object Vutf_2000_version;
@@ -815,11 +1158,12 @@ Lisp_Object Qascii,
 #ifdef UTF2000
   Qucs_bmp,
   Qlatin_viscii,
+  Qlatin_tcvn5712,
   Qlatin_viscii_lower,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
-  Qideograph_daikanwa,
+  Qmojikyo,
   Qmojikyo_pj_1,
   Qmojikyo_pj_2,
   Qmojikyo_pj_3,
@@ -851,13 +1195,6 @@ Lisp_Object Ql2r, Qr2l;
 
 Lisp_Object Vcharset_hash_table;
 
-#ifdef UTF2000
-static Charset_ID next_allocated_leading_byte;
-#else
-static Charset_ID next_allocated_1_byte_leading_byte;
-static Charset_ID next_allocated_2_byte_leading_byte;
-#endif
-
 /* Composite characters are characters constructed by overstriking two
    or more regular characters.
 
@@ -968,7 +1305,7 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
    Use the macro charptr_emchar() instead. */
 
 Emchar
-non_ascii_charptr_emchar (CONST Bufbyte *str)
+non_ascii_charptr_emchar (const Bufbyte *str)
 {
 #ifdef UTF2000
   Bufbyte b;
@@ -1124,7 +1461,7 @@ non_ascii_valid_char_p (Emchar ch)
    charptr_copy_char() instead. */
 
 Bytecount
-non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str)
+non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
 {
   Bufbyte *strptr = str;
   *strptr = *ptr++;
@@ -1217,7 +1554,7 @@ Lstream_funget_emchar (Lstream *stream, Emchar ch)
 static Lisp_Object
 mark_charset (Lisp_Object obj)
 {
-  struct Lisp_Charset *cs = XCHARSET (obj);
+  Lisp_Charset *cs = XCHARSET (obj);
 
   mark_object (cs->short_name);
   mark_object (cs->long_name);
@@ -1225,7 +1562,8 @@ mark_charset (Lisp_Object obj)
   mark_object (cs->registry);
   mark_object (cs->ccl_program);
 #ifdef UTF2000
-  mark_object (cs->decoding_table);
+  /* mark_object (cs->encoding_table); */
+  /* mark_object (cs->decoding_table); */
 #endif
   return cs->name;
 }
@@ -1233,7 +1571,7 @@ mark_charset (Lisp_Object obj)
 static void
 print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-  struct Lisp_Charset *cs = XCHARSET (obj);
+  Lisp_Charset *cs = XCHARSET (obj);
   char buf[200];
 
   if (print_readably)
@@ -1249,11 +1587,9 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
   print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
   write_c_string (" ", printcharfun);
   print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);
-  sprintf (buf, " %s %s cols=%d g%d final='%c' reg=",
-	   CHARSET_TYPE (cs) == CHARSET_TYPE_94    ? "94" :
-	   CHARSET_TYPE (cs) == CHARSET_TYPE_96    ? "96" :
-	   CHARSET_TYPE (cs) == CHARSET_TYPE_94X94 ? "94x94" :
-	   "96x96",
+  sprintf (buf, " %d^%d %s cols=%d g%d final='%c' reg=",
+	   CHARSET_CHARS (cs),
+	   CHARSET_DIMENSION (cs),
 	   CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l",
 	   CHARSET_COLUMNS (cs),
 	   CHARSET_GRAPHIC (cs),
@@ -1265,9 +1601,16 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 }
 
 static const struct lrecord_description charset_description[] = {
-  { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, name), 7 },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
 #ifdef UTF2000
-  { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, decoding_table), 2 },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, decoding_table) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) },
 #endif
   { XD_END }
 };
@@ -1275,12 +1618,13 @@ static const struct lrecord_description charset_description[] = {
 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
                                mark_charset, print_charset, 0, 0, 0,
 			       charset_description,
-			       struct Lisp_Charset);
+			       Lisp_Charset);
 /* Make a new charset. */
 
 static Lisp_Object
 make_charset (Charset_ID id, Lisp_Object name,
-	      unsigned char type, unsigned char columns, unsigned char graphic,
+	      unsigned short chars, unsigned char dimension,
+	      unsigned char columns, unsigned char graphic,
 	      Bufbyte final, unsigned char direction, Lisp_Object short_name,
 	      Lisp_Object long_name, Lisp_Object doc,
 	      Lisp_Object reg,
@@ -1288,17 +1632,21 @@ make_charset (Charset_ID id, Lisp_Object name,
 	      Emchar ucs_min, Emchar ucs_max,
 	      Emchar code_offset, unsigned char byte_offset)
 {
+  unsigned char type = 0;
   Lisp_Object obj;
-  struct Lisp_Charset *cs =
-    alloc_lcrecord_type (struct Lisp_Charset, &lrecord_charset);
+  Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
+
+  zero_lcrecord (cs);
+
   XSETCHARSET (obj, cs);
 
   CHARSET_ID		(cs) = id;
   CHARSET_NAME		(cs) = name;
   CHARSET_SHORT_NAME	(cs) = short_name;
   CHARSET_LONG_NAME	(cs) = long_name;
+  CHARSET_CHARS		(cs) = chars;
+  CHARSET_DIMENSION	(cs) = dimension;
   CHARSET_DIRECTION	(cs) = direction;
-  CHARSET_TYPE		(cs) = type;
   CHARSET_COLUMNS	(cs) = columns;
   CHARSET_GRAPHIC	(cs) = graphic;
   CHARSET_FINAL		(cs) = final;
@@ -1308,49 +1656,65 @@ make_charset (Charset_ID id, Lisp_Object name,
   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;
 #endif
 
-  switch (CHARSET_TYPE (cs))
+  switch (CHARSET_CHARS (cs))
     {
-    case CHARSET_TYPE_94:
-      CHARSET_DIMENSION (cs) = 1;
-      CHARSET_CHARS (cs) = 94;
-      break;
-    case CHARSET_TYPE_96:
-      CHARSET_DIMENSION (cs) = 1;
-      CHARSET_CHARS (cs) = 96;
-      break;
-    case CHARSET_TYPE_94X94:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 94;
+    case 94:
+      switch (CHARSET_DIMENSION (cs))
+	{
+	case 1:
+	  type = CHARSET_TYPE_94;
+	  break;
+	case 2:
+	  type = CHARSET_TYPE_94X94;
+	  break;
+	}
       break;
-    case CHARSET_TYPE_96X96:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 96;
+    case 96:
+      switch (CHARSET_DIMENSION (cs))
+	{
+	case 1:
+	  type = CHARSET_TYPE_96;
+	  break;
+	case 2:
+	  type = CHARSET_TYPE_96X96;
+	  break;
+	}
       break;
 #ifdef UTF2000
-    case CHARSET_TYPE_128:
-      CHARSET_DIMENSION (cs) = 1;
-      CHARSET_CHARS (cs) = 128;
-      break;
-    case CHARSET_TYPE_128X128:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 128;
-      break;
-    case CHARSET_TYPE_256:
-      CHARSET_DIMENSION (cs) = 1;
-      CHARSET_CHARS (cs) = 256;
+    case 128:
+      switch (CHARSET_DIMENSION (cs))
+	{
+	case 1:
+	  type = CHARSET_TYPE_128;
+	  break;
+	case 2:
+	  type = CHARSET_TYPE_128X128;
+	  break;
+	}
       break;
-    case CHARSET_TYPE_256X256:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 256;
+    case 256:
+      switch (CHARSET_DIMENSION (cs))
+	{
+	case 1:
+	  type = CHARSET_TYPE_256;
+	  break;
+	case 2:
+	  type = CHARSET_TYPE_256X256;
+	  break;
+	}
       break;
 #endif
     }
+#ifndef UTF2000
+  CHARSET_TYPE (cs) = type;
+#endif
 
 #ifndef UTF2000
   if (id == LEADING_BYTE_ASCII)
@@ -1394,24 +1758,24 @@ get_unallocated_leading_byte (int dimension)
   Charset_ID lb;
 
 #ifdef UTF2000
-  if (next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
+  if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
     lb = 0;
   else
-    lb = next_allocated_leading_byte++;
+    lb = chlook->next_allocated_leading_byte++;
 #else
   if (dimension == 1)
     {
-      if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
+      if (chlook->next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
 	lb = 0;
       else
-	lb = next_allocated_1_byte_leading_byte++;
+	lb = chlook->next_allocated_1_byte_leading_byte++;
     }
   else
     {
-      if (next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
+      if (chlook->next_allocated_2_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_2)
 	lb = 0;
       else
-	lb = next_allocated_2_byte_leading_byte++;
+	lb = chlook->next_allocated_2_byte_leading_byte++;
     }
 #endif
 
@@ -1424,7 +1788,58 @@ get_unallocated_leading_byte (int dimension)
 }
 
 #ifdef UTF2000
-Lisp_Object
+Emchar
+make_builtin_char (Lisp_Object charset, int c1, int c2)
+{
+  if (XCHARSET_UCS_MAX (charset))
+    {
+      Emchar code
+	= (XCHARSET_DIMENSION (charset) == 1
+	   ?
+	   c1 - XCHARSET_BYTE_OFFSET (charset)
+	   :
+	   (c1 - XCHARSET_BYTE_OFFSET (charset)) * XCHARSET_CHARS (charset)
+	   + c2  - XCHARSET_BYTE_OFFSET (charset))
+	- XCHARSET_CODE_OFFSET (charset) + XCHARSET_UCS_MIN (charset);
+      if ((code < XCHARSET_UCS_MIN (charset))
+	  || (XCHARSET_UCS_MAX (charset) < code))
+	signal_simple_error ("Arguments makes invalid character",
+			     make_char (code));
+      return code;
+    }
+  else if (XCHARSET_DIMENSION (charset) == 1)
+    {
+      switch (XCHARSET_CHARS (charset))
+	{
+	case 94:
+	  return MIN_CHAR_94
+	    + (XCHARSET_FINAL (charset) - '0') * 94 + (c1 - 33);
+	case 96:
+	  return MIN_CHAR_96
+	    + (XCHARSET_FINAL (charset) - '0') * 96 + (c1 - 32);
+	default:
+	  abort ();
+	}
+    }
+  else
+    {
+      switch (XCHARSET_CHARS (charset))
+	{
+	case 94:
+	  return MIN_CHAR_94x94
+	    + (XCHARSET_FINAL (charset) - '0') * 94 * 94
+	    + (c1 - 33) * 94 + (c2 - 33);
+	case 96:
+	  return MIN_CHAR_96x96
+	    + (XCHARSET_FINAL (charset) - '0') * 96 * 96
+	    + (c1 - 32) * 96 + (c2 - 32);
+	default:
+	  abort ();
+	}
+    }
+}
+
+int
 range_charset_code_point (Lisp_Object charset, Emchar ch)
 {
   int d;
@@ -1433,37 +1848,35 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
       && (ch <= XCHARSET_UCS_MAX (charset)))
     {
       d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset);
-		       
-      if (XCHARSET_DIMENSION (charset) == 1)
-	return list1 (make_int (d + XCHARSET_BYTE_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 list2 (make_int (d / XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d % XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)));
+	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 list3 (make_int (d / (XCHARSET_CHARS (charset)
-					* XCHARSET_CHARS (charset))
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d / XCHARSET_CHARS (charset)
-				% XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d % XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)));
+	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 list4 (make_int (d / (XCHARSET_CHARS (charset)
-					* XCHARSET_CHARS (charset)
-					* XCHARSET_CHARS (charset))
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d / (XCHARSET_CHARS (charset)
-					* XCHARSET_CHARS (charset))
-				% XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d / XCHARSET_CHARS (charset)
-				% XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)),
-		      make_int (d % XCHARSET_CHARS (charset)
-				+ XCHARSET_BYTE_OFFSET (charset)));
+	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)
     {
@@ -1474,17 +1887,17 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 	      if (((d = ch - (MIN_CHAR_94
 			      + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0)
 		  && (d < 94))
-		return list1 (make_int (d + 33));
+		return d + 33;
 	    }
 	  else if (XCHARSET_CHARS (charset) == 96)
 	    {
 	      if (((d = ch - (MIN_CHAR_96
 			      + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0)
 		  && (d < 96))
-		return list1 (make_int (d + 32));
+		return d + 32;
 	    }
 	  else
-	    return Qnil;
+	    return -1;
 	}
       else if (XCHARSET_DIMENSION (charset) == 2)
 	{
@@ -1494,8 +1907,7 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 			      + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
 		   >= 0)
 		  && (d < 94 * 94))
-		return list2 (make_int ((d / 94) + 33),
-			      make_int (d % 94 + 33));
+		return (((d / 94) + 33) << 8) | (d % 94 + 33);
 	    }
 	  else if (XCHARSET_CHARS (charset) == 96)
 	    {
@@ -1503,117 +1915,151 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 			      + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
 		   >= 0)
 		  && (d < 96 * 96))
-		return list2 (make_int ((d / 96) + 32),
-			      make_int (d % 96 + 32));
+		return (((d / 96) + 32) << 8) | (d % 96 + 32);
 	    }
+	  else
+	    return -1;
 	}
     }
-  return Qnil;
+  return -1;
 }
 
-Lisp_Object
-split_builtin_char (Emchar c)
+int
+encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
 {
   if (c <= MAX_CHAR_BASIC_LATIN)
     {
-      return list2 (Vcharset_ascii, make_int (c));
+      *charset = Vcharset_ascii;
+      return c;
     }
   else if (c < 0xA0)
     {
-      return list2 (Vcharset_control_1, make_int (c & 0x7F));
+      *charset = Vcharset_control_1;
+      return c & 0x7F;
     }
   else if (c <= 0xff)
     {
-      return list2 (Vcharset_latin_iso8859_1, make_int (c & 0x7F));
+      *charset = Vcharset_latin_iso8859_1;
+      return c & 0x7F;
     }
+  /*
   else if ((MIN_CHAR_GREEK <= c) && (c <= MAX_CHAR_GREEK))
     {
-      return list2 (Vcharset_greek_iso8859_7,
-		    make_int (c - MIN_CHAR_GREEK + 0x20));
+      *charset = Vcharset_greek_iso8859_7;
+      return c - MIN_CHAR_GREEK + 0x20;
     }
   else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC))
     {
-      return list2 (Vcharset_cyrillic_iso8859_5,
-		    make_int (c - MIN_CHAR_CYRILLIC + 0x20));
+      *charset = Vcharset_cyrillic_iso8859_5;
+      return c - MIN_CHAR_CYRILLIC + 0x20;
     }
+  */
   else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW))
     {
-      return list2 (Vcharset_hebrew_iso8859_8,
-		    make_int (c - MIN_CHAR_HEBREW + 0x20));
+      *charset = Vcharset_hebrew_iso8859_8;
+      return c - MIN_CHAR_HEBREW + 0x20;
     }
   else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
     {
-      return list2 (Vcharset_thai_tis620,
-		    make_int (c - MIN_CHAR_THAI + 0x20));
+      *charset = Vcharset_thai_tis620;
+      return c - MIN_CHAR_THAI + 0x20;
     }
+  /*
   else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c)
 	   && (c <= MAX_CHAR_HALFWIDTH_KATAKANA))
     {
       return list2 (Vcharset_katakana_jisx0201,
 		    make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33));
     }
+  */
   else if (c <= MAX_CHAR_BMP)
     {
-      return list3 (Vcharset_ucs_bmp,
-		    make_int (c >> 8), make_int (c & 0xff));
+      *charset = Vcharset_ucs_bmp;
+      return c;
+    }
+  else if (c < MIN_CHAR_DAIKANWA)
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+  /*
+  else if (c <= MAX_CHAR_DAIKANWA)
+    {
+      *charset = Vcharset_ideograph_daikanwa;
+      return c - MIN_CHAR_DAIKANWA;
     }
-  else if ((MIN_CHAR_DAIKANWA <= c) && (c <= MAX_CHAR_DAIKANWA))
+  */
+  else if (c <= MAX_CHAR_MOJIKYO)
     {
-      return list3 (Vcharset_ideograph_daikanwa,
-		    make_int ((c - MIN_CHAR_DAIKANWA) >> 8),
-		    make_int ((c - MIN_CHAR_DAIKANWA) & 255));
+      *charset = Vcharset_mojikyo;
+      return c - MIN_CHAR_MOJIKYO;
+    }
+  else if (c < MIN_CHAR_94)
+    {
+      *charset = Vcharset_ucs;
+      return c;
     }
   else if (c <= MAX_CHAR_94)
     {
-      return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94,
-					   ((c - MIN_CHAR_94) / 94) + '0',
-					   CHARSET_LEFT_TO_RIGHT),
-		    make_int (((c - MIN_CHAR_94) % 94) + 33));
+      *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94,
+					((c - MIN_CHAR_94) / 94) + '0',
+					CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+	return ((c - MIN_CHAR_94) % 94) + 33;
+      else
+	{
+	  *charset = Vcharset_ucs;
+	  return c;
+	}
     }
   else if (c <= MAX_CHAR_96)
     {
-      return list2 (CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96,
-					   ((c - MIN_CHAR_96) / 96) + '0',
-					   CHARSET_LEFT_TO_RIGHT),
-		    make_int (((c - MIN_CHAR_96) % 96) + 32));
+      *charset = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96,
+					((c - MIN_CHAR_96) / 96) + '0',
+					CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+	return ((c - MIN_CHAR_96) % 96) + 32;
+      else
+	{
+	  *charset = Vcharset_ucs;
+	  return c;
+	}
     }
   else if (c <= MAX_CHAR_94x94)
     {
-      return list3 (CHARSET_BY_ATTRIBUTES
-		    (CHARSET_TYPE_94X94,
-		     ((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
-		     CHARSET_LEFT_TO_RIGHT),
-		    make_int ((((c - MIN_CHAR_94x94) / 94) % 94) + 33),
-		    make_int (((c - MIN_CHAR_94x94) % 94) + 33));
+      *charset
+	= CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94,
+				 ((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
+				 CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+	return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8)
+	  | (((c - MIN_CHAR_94x94) % 94) + 33);
+      else
+	{
+	  *charset = Vcharset_ucs;
+	  return c;
+	}
     }
   else if (c <= MAX_CHAR_96x96)
     {
-      return list3 (CHARSET_BY_ATTRIBUTES
-		    (CHARSET_TYPE_96X96,
-		     ((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
-		     CHARSET_LEFT_TO_RIGHT),
-		    make_int ((((c - MIN_CHAR_96x96) / 96) % 96) + 32),
-		    make_int (((c - MIN_CHAR_96x96) % 96) + 32));
+      *charset
+	= CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_96X96,
+				 ((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
+				 CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+	return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8
+	  | (((c - MIN_CHAR_96x96) % 96) + 32);
+      else
+	{
+	  *charset = Vcharset_ucs;
+	  return c;
+	}
     }
   else
     {
-      return Qnil;
-    }
-}
-
-Lisp_Object
-charset_code_point (Lisp_Object charset, Emchar ch)
-{
-  Lisp_Object cdef = get_char_code_table (ch, Vcharacter_attribute_table);
-
-  if (!EQ (cdef, Qnil))
-    {
-      Lisp_Object field = Fassq (charset, cdef);
-
-      if (!EQ (field, Qnil))
-	return Fcdr (field);
+      *charset = Vcharset_ucs;
+      return c;
     }
-  return range_charset_code_point (charset, ch);
 }
 
 Lisp_Object Vdefault_coded_charset_priority_list;
@@ -1678,7 +2124,7 @@ add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value,
     (struct charset_list_closure*) charset_list_closure;
   Lisp_Object *charset_list = chcl->charset_list;
 
-  *charset_list = Fcons (XCHARSET_NAME (value), *charset_list);
+  *charset_list = Fcons (key /* XCHARSET_NAME (value) */, *charset_list);
   return 0;
 }
 
@@ -1903,7 +2349,7 @@ character set.  Recognized properties are:
 	byte_offset = 0;
     }
 
-  charset = make_charset (id, name, type, columns, graphic,
+  charset = make_charset (id, name, chars, dimension, columns, graphic,
 			  final, direction, short_name, long_name,
 			  doc_string, registry,
 			  Qnil, 0, 0, 0, byte_offset);
@@ -1920,10 +2366,10 @@ NEW-NAME is the name of the new charset.  Return the new charset.
        (charset, new_name))
 {
   Lisp_Object new_charset = Qnil;
-  int id, dimension, columns, graphic, final;
-  int direction, type;
+  int id, chars, dimension, columns, graphic, final;
+  int direction;
   Lisp_Object registry, doc_string, short_name, long_name;
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
 
   charset = Fget_charset (charset);
   if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
@@ -1936,9 +2382,9 @@ NEW-NAME is the name of the new charset.  Return the new charset.
 
   cs = XCHARSET (charset);
 
-  type      = CHARSET_TYPE      (cs);
-  columns   = CHARSET_COLUMNS   (cs);
+  chars     = CHARSET_CHARS     (cs);
   dimension = CHARSET_DIMENSION (cs);
+  columns   = CHARSET_COLUMNS   (cs);
   id = get_unallocated_leading_byte (dimension);
 
   graphic = CHARSET_GRAPHIC (cs);
@@ -1951,7 +2397,7 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   long_name = CHARSET_LONG_NAME (cs);
   registry = CHARSET_REGISTRY (cs);
 
-  new_charset = make_charset (id, new_name, type, columns,
+  new_charset = make_charset (id, new_name, chars, dimension, columns,
 			      graphic, final, direction, short_name, long_name,
 			      doc_string, registry,
 #ifdef UTF2000
@@ -2092,7 +2538,7 @@ Recognized properties are those listed in `make-charset', as well as
 */
        (charset, prop))
 {
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
 
   charset = Fget_charset (charset);
   cs = XCHARSET (charset);
@@ -2187,39 +2633,42 @@ Set mapping-table of CHARSET to TABLE.
        (charset, table))
 {
   struct Lisp_Charset *cs;
-  Lisp_Object old_table;
   size_t i;
+  int byte_offset;
 
   charset = Fget_charset (charset);
   cs = XCHARSET (charset);
 
-  if (EQ (table, Qnil))
+  if (NILP (table))
     {
-      CHARSET_DECODING_TABLE(cs) = table;
+      if (VECTORP (CHARSET_DECODING_TABLE(cs)))
+	make_vector_newer (CHARSET_DECODING_TABLE(cs));
+      CHARSET_DECODING_TABLE(cs) = Qnil;
       return table;
     }
   else if (VECTORP (table))
     {
-      int ccs_len;
-
-      /* ad-hoc method for `ascii' */
-      if ((CHARSET_CHARS (cs) == 94) &&
-	  (CHARSET_BYTE_OFFSET (cs) != 33))
-	ccs_len = 128 - CHARSET_BYTE_OFFSET (cs);
-      else
-	ccs_len = CHARSET_CHARS (cs);
-
-      if (XVECTOR_LENGTH (table) > ccs_len)
-	args_out_of_range (table, make_int (CHARSET_CHARS (cs)));
-      old_table = CHARSET_DECODING_TABLE(cs);
-      CHARSET_DECODING_TABLE(cs) = table;
+      int ccs_len = CHARSET_BYTE_SIZE (cs);
+      int ret = decoding_table_check_elements (table,
+					       CHARSET_DIMENSION (cs),
+					       ccs_len);
+      if (ret)
+	{
+	  if (ret == -1)
+	    signal_simple_error ("Too big table", table);
+	  else if (ret == -2)
+	    signal_simple_error ("Invalid element is found", table);
+	  else
+	    signal_simple_error ("Something wrong", table);
+	}
+      CHARSET_DECODING_TABLE(cs) = Qnil;
     }
   else
     signal_error (Qwrong_type_argument,
 		  list2 (build_translated_string ("vector-or-nil-p"),
 			 table));
-  /* signal_simple_error ("Wrong type argument: vector-or-nil-p", table); */
 
+  byte_offset = CHARSET_BYTE_OFFSET (cs);
   switch (CHARSET_DIMENSION (cs))
     {
     case 1:
@@ -2228,9 +2677,8 @@ Set mapping-table of CHARSET to TABLE.
 	  Lisp_Object c = XVECTOR_DATA(table)[i];
 
 	  if (CHARP (c))
-	    put_char_attribute
-	      (c, charset,
-	       list1 (make_int (i + CHARSET_BYTE_OFFSET (cs))));
+	    put_char_ccs_code_point (c, charset,
+				     make_int (i + byte_offset));
 	}
       break;
     case 2:
@@ -2242,28 +2690,21 @@ Set mapping-table of CHARSET to TABLE.
 	    {
 	      size_t j;
 
-	      if (XVECTOR_LENGTH (v) > CHARSET_CHARS (cs))
-		{
-		  CHARSET_DECODING_TABLE(cs) = old_table;
-		  args_out_of_range (v, make_int (CHARSET_CHARS (cs)));
-		}
 	      for (j = 0; j < XVECTOR_LENGTH (v); j++)
 		{
 		  Lisp_Object c = XVECTOR_DATA(v)[j];
 
 		  if (CHARP (c))
-		    put_char_attribute (c, charset,
-					list2
-					(make_int
-					 (i + CHARSET_BYTE_OFFSET (cs)),
-					 make_int
-					 (j + CHARSET_BYTE_OFFSET (cs))));
+		    put_char_ccs_code_point
+		      (c, charset,
+		       make_int ( ( (i + byte_offset) << 8 )
+				  | (j + byte_offset)
+				  ) );
 		}
 	    }
 	  else if (CHARP (v))
-	    put_char_attribute (v, charset,
-				list1
-				(make_int (i + CHARSET_BYTE_OFFSET (cs))));
+	    put_char_ccs_code_point (v, charset,
+				     make_int (i + byte_offset));
 	}
       break;
     }
@@ -2276,6 +2717,94 @@ Set mapping-table of CHARSET to TABLE.
 /*              Lisp primitives for working with characters             */
 /************************************************************************/
 
+#ifdef UTF2000
+DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /*
+Make a character from CHARSET and code-point CODE.
+*/
+       (charset, code))
+{
+  int c;
+
+  charset = Fget_charset (charset);
+  CHECK_INT (code);
+  c = XINT (code);
+  if (XCHARSET_GRAPHIC (charset) == 1)
+    c &= 0x7F7F7F7F;
+  return make_char (DECODE_CHAR (charset, c));
+}
+
+DEFUN ("decode-builtin-char", Fdecode_builtin_char, 2, 2, 0, /*
+Make a builtin character from CHARSET and code-point CODE.
+*/
+       (charset, code))
+{
+  int c;
+  int final;
+
+  charset = Fget_charset (charset);
+  CHECK_INT (code);
+  c = XINT (code);
+
+  if ((final = XCHARSET_FINAL (charset)) >= '0')
+    {
+      if (XCHARSET_DIMENSION (charset) == 1)
+	{
+	  switch (XCHARSET_CHARS (charset))
+	    {
+	    case 94:
+	      return
+		make_char (MIN_CHAR_94 + (final - '0') * 94
+			   + ((c & 0x7F) - 33));
+	    case 96:
+	      return
+		make_char (MIN_CHAR_96 + (final - '0') * 96
+			   + ((c & 0x7F) - 32));
+	    default:
+	      return Fdecode_char (charset, code);
+	    }
+	}
+      else
+	{
+	  switch (XCHARSET_CHARS (charset))
+	    {
+	    case 94:
+	      return
+		make_char (MIN_CHAR_94x94
+			   + (final - '0') * 94 * 94
+			   + (((c >> 8) & 0x7F) - 33) * 94
+			   + ((c & 0x7F) - 33));
+	    case 96:
+	      return
+		make_char (MIN_CHAR_96x96
+			   + (final - '0') * 96 * 96
+			   + (((c >> 8) & 0x7F) - 32) * 96
+			   + ((c & 0x7F) - 32));
+	    default:
+	      return Fdecode_char (charset, code);
+	    }
+	}
+    }
+  else if (XCHARSET_UCS_MAX (charset))
+    {
+      Emchar cid
+	= (XCHARSET_DIMENSION (charset) == 1
+	   ?
+	   c - XCHARSET_BYTE_OFFSET (charset)
+	   :
+	   ((c >> 8) - XCHARSET_BYTE_OFFSET (charset))
+	   * XCHARSET_CHARS (charset)
+	   + (c & 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 Fdecode_char (charset, code);
+      return make_char (cid);
+    }
+  else
+    return Fdecode_char (charset, code);
+}
+#endif
+
 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
 Make a character from CHARSET and octets ARG1 and ARG2.
 ARG2 is required only for characters from two-dimensional charsets.
@@ -2284,7 +2813,7 @@ character s with caron.
 */
        (charset, arg1, arg2))
 {
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
   int a1, a2;
   int lowlim, highlim;
 
@@ -2372,27 +2901,31 @@ Return list of charset and one or two position-codes of CHAR.
 */
        (character))
 {
-#ifdef UTF2000
-  Lisp_Object ret;
-  Lisp_Object charset;
-
-  CHECK_CHAR_COERCE_INT (character);
-  ret = SPLIT_CHAR (XCHAR (character));
-  charset = Fcar (ret);
-  if (CHARSETP (charset))
-    return Fcons (XCHARSET_NAME (charset), Fcopy_list (Fcdr (ret)));
-  else
-    return ret;
-#else
   /* This function can GC */
   struct gcpro gcpro1, gcpro2;
   Lisp_Object charset = Qnil;
   Lisp_Object rc = Qnil;
+#ifdef UTF2000
+  int code_point;
+  int dimension;
+#else
   int c1, c2;
+#endif
 
   GCPRO2 (charset, rc);
   CHECK_CHAR_COERCE_INT (character);
 
+#ifdef UTF2000
+  code_point = ENCODE_CHAR (XCHAR (character), charset);
+  dimension = XCHARSET_DIMENSION (charset);
+  while (dimension > 0)
+    {
+      rc = Fcons (make_int (code_point & 255), rc);
+      code_point >>= 8;
+      dimension--;
+    }
+  rc = Fcons (XCHARSET_NAME (charset), rc);
+#else
   BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
 
   if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
@@ -2403,10 +2936,10 @@ Return list of charset and one or two position-codes of CHAR.
     {
       rc = list2 (XCHARSET_NAME (charset), make_int (c1));
     }
+#endif
   UNGCPRO;
 
   return rc;
-#endif
 }
 
 
@@ -2491,6 +3024,12 @@ Return a string of the characters comprising a composite character.
 void
 syms_of_mule_charset (void)
 {
+#ifdef UTF2000
+  INIT_LRECORD_IMPLEMENTATION (byte_table);
+  INIT_LRECORD_IMPLEMENTATION (char_id_table);
+#endif
+  INIT_LRECORD_IMPLEMENTATION (charset);
+
   DEFSUBR (Fcharsetp);
   DEFSUBR (Ffind_charset);
   DEFSUBR (Fget_charset);
@@ -2510,9 +3049,11 @@ syms_of_mule_charset (void)
   DEFSUBR (Fset_charset_ccl_program);
   DEFSUBR (Fset_charset_registry);
 #ifdef UTF2000
+  DEFSUBR (Fchar_attribute_list);
   DEFSUBR (Fchar_attribute_alist);
   DEFSUBR (Fget_char_attribute);
   DEFSUBR (Fput_char_attribute);
+  DEFSUBR (Fremove_char_attribute);
   DEFSUBR (Fdefine_char);
   DEFSUBR (Fchar_variants);
   DEFSUBR (Fget_composite_char);
@@ -2520,6 +3061,10 @@ syms_of_mule_charset (void)
   DEFSUBR (Fset_charset_mapping_table);
 #endif
 
+#ifdef UTF2000
+  DEFSUBR (Fdecode_char);
+  DEFSUBR (Fdecode_builtin_char);
+#endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
   DEFSUBR (Fchar_octet);
@@ -2588,11 +3133,13 @@ syms_of_mule_charset (void)
   defsymbol (&Qucs,			"ucs");
   defsymbol (&Qucs_bmp,			"ucs-bmp");
   defsymbol (&Qlatin_viscii,		"latin-viscii");
+  defsymbol (&Qlatin_tcvn5712,		"latin-tcvn5712");
   defsymbol (&Qlatin_viscii_lower,	"latin-viscii-lower");
   defsymbol (&Qlatin_viscii_upper,	"latin-viscii-upper");
   defsymbol (&Qvietnamese_viscii_lower,	"vietnamese-viscii-lower");
   defsymbol (&Qvietnamese_viscii_upper,	"vietnamese-viscii-upper");
   defsymbol (&Qideograph_daikanwa,	"ideograph-daikanwa");
+  defsymbol (&Qmojikyo,			"mojikyo");
   defsymbol (&Qmojikyo_pj_1,		"mojikyo-pj-1");
   defsymbol (&Qmojikyo_pj_2,		"mojikyo-pj-2");
   defsymbol (&Qmojikyo_pj_3,		"mojikyo-pj-3");
@@ -2651,10 +3198,10 @@ vars_of_mule_charset (void)
 #endif
 
 #ifdef UTF2000
-  next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
+  chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
 #else
-  next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
-  next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
+  chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
+  chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
 #endif
 
 #ifndef UTF2000
@@ -2666,19 +3213,16 @@ Leading-code of private TYPE9N charset of column-width 1.
 #endif
 
 #ifdef UTF2000
-  Vutf_2000_version = build_string("0.13 (Takaida)");
+  Vutf_2000_version = build_string("0.16 (Ōji)");
   DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
 Version number of UTF-2000.
 */ );
 
-  staticpro (&Vcharacter_attribute_table);
-  Vcharacter_attribute_table = make_char_code_table (Qnil);
-
   staticpro (&Vcharacter_composition_table);
-  Vcharacter_composition_table = make_char_code_table (Qnil);
+  Vcharacter_composition_table = make_char_id_table (Qnil, -1);
 
   staticpro (&Vcharacter_variant_table);
-  Vcharacter_variant_table = make_char_code_table (Qnil);
+  Vcharacter_variant_table = make_char_id_table (Qnil, 0);
 
   Vdefault_coded_charset_priority_list = Qnil;
   DEFVAR_LISP ("default-coded-charset-priority-list",
@@ -2699,11 +3243,23 @@ complex_vars_of_mule_charset (void)
      ease of access. */
 
 #ifdef UTF2000
+  staticpro (&Vchar_attribute_hash_table);
+  Vchar_attribute_hash_table
+    = make_lisp_hash_table (16, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
+
+  staticpro (&Vcharset_ucs);
+  Vcharset_ucs =
+    make_charset (LEADING_BYTE_UCS, Qucs, 256, 4,
+		  1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+		  build_string ("UCS"),
+		  build_string ("UCS"),
+		  build_string ("ISO/IEC 10646"),
+		  build_string (""),
+		  Qnil, 0, 0xFFFFFFF, 0, 0);
   staticpro (&Vcharset_ucs_bmp);
   Vcharset_ucs_bmp =
-    make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp,
-		  CHARSET_TYPE_256X256, 1, 2, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    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 ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
@@ -2712,20 +3268,15 @@ complex_vars_of_mule_charset (void)
 #else
 # define MIN_CHAR_THAI 0
 # define MAX_CHAR_THAI 0
-# define MIN_CHAR_GREEK 0
-# define MAX_CHAR_GREEK 0
 # define MIN_CHAR_HEBREW 0
 # define MAX_CHAR_HEBREW 0
 # define MIN_CHAR_HALFWIDTH_KATAKANA 0
 # define MAX_CHAR_HALFWIDTH_KATAKANA 0
-# define MIN_CHAR_CYRILLIC 0
-# define MAX_CHAR_CYRILLIC 0
 #endif
   staticpro (&Vcharset_ascii);
   Vcharset_ascii =
-    make_charset (LEADING_BYTE_ASCII, Qascii,
-		  CHARSET_TYPE_94, 1, 0, 'B',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1,
+		  1, 0, 'B', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("ASCII"),
 		  build_string ("ASCII)"),
 		  build_string ("ASCII (ISO646 IRV)"),
@@ -2733,9 +3284,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0x7F, 0, 0);
   staticpro (&Vcharset_control_1);
   Vcharset_control_1 =
-    make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1,
-		  CHARSET_TYPE_94, 1, 1, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
+		  1, 1, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("C1"),
 		  build_string ("Control characters"),
 		  build_string ("Control characters 128-191"),
@@ -2743,9 +3293,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0x80, 0x9F, 0, 0);
   staticpro (&Vcharset_latin_iso8859_1);
   Vcharset_latin_iso8859_1 =
-    make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1,
-		  CHARSET_TYPE_96, 1, 1, 'A',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
+		  1, 1, 'A', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Latin-1"),
 		  build_string ("ISO8859-1 (Latin-1)"),
 		  build_string ("ISO8859-1 (Latin-1)"),
@@ -2753,9 +3302,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0xA0, 0xFF, 0, 32);
   staticpro (&Vcharset_latin_iso8859_2);
   Vcharset_latin_iso8859_2 =
-    make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2,
-		  CHARSET_TYPE_96, 1, 1, 'B',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
+		  1, 1, 'B', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Latin-2"),
 		  build_string ("ISO8859-2 (Latin-2)"),
 		  build_string ("ISO8859-2 (Latin-2)"),
@@ -2763,9 +3311,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_latin_iso8859_3);
   Vcharset_latin_iso8859_3 =
-    make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3,
-		  CHARSET_TYPE_96, 1, 1, 'C',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
+		  1, 1, 'C', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Latin-3"),
 		  build_string ("ISO8859-3 (Latin-3)"),
 		  build_string ("ISO8859-3 (Latin-3)"),
@@ -2773,9 +3320,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_latin_iso8859_4);
   Vcharset_latin_iso8859_4 =
-    make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4,
-		  CHARSET_TYPE_96, 1, 1, 'D',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
+		  1, 1, 'D', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Latin-4"),
 		  build_string ("ISO8859-4 (Latin-4)"),
 		  build_string ("ISO8859-4 (Latin-4)"),
@@ -2783,9 +3329,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =
-    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620,
-		  CHARSET_TYPE_96, 1, 1, 'T',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
+		  1, 1, 'T', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("TIS620"),
 		  build_string ("TIS620 (Thai)"),
 		  build_string ("TIS620.2529 (Thai)"),
@@ -2793,19 +3338,19 @@ complex_vars_of_mule_charset (void)
 		  Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32);
   staticpro (&Vcharset_greek_iso8859_7);
   Vcharset_greek_iso8859_7 =
-    make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7,
-		  CHARSET_TYPE_96, 1, 1, 'F',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
+		  1, 1, 'F', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("ISO8859-7"),
 		  build_string ("ISO8859-7 (Greek)"),
 		  build_string ("ISO8859-7 (Greek)"),
 		  build_string ("iso8859-7"),
-		  Qnil, MIN_CHAR_GREEK, MAX_CHAR_GREEK, 0, 32);
+		  Qnil,
+		  0 /* MIN_CHAR_GREEK */,
+		  0 /* MAX_CHAR_GREEK */, 0, 32);
   staticpro (&Vcharset_arabic_iso8859_6);
   Vcharset_arabic_iso8859_6 =
-    make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6,
-		  CHARSET_TYPE_96, 1, 1, 'G',
-		  CHARSET_RIGHT_TO_LEFT,
+    make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
+		  1, 1, 'G', CHARSET_RIGHT_TO_LEFT,
 		  build_string ("ISO8859-6"),
 		  build_string ("ISO8859-6 (Arabic)"),
 		  build_string ("ISO8859-6 (Arabic)"),
@@ -2813,9 +3358,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_hebrew_iso8859_8);
   Vcharset_hebrew_iso8859_8 =
-    make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8,
-		  CHARSET_TYPE_96, 1, 1, 'H',
-		  CHARSET_RIGHT_TO_LEFT,
+    make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
+		  1, 1, 'H', CHARSET_RIGHT_TO_LEFT,
 		  build_string ("ISO8859-8"),
 		  build_string ("ISO8859-8 (Hebrew)"),
 		  build_string ("ISO8859-8 (Hebrew)"),
@@ -2823,9 +3367,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, MIN_CHAR_HEBREW, MAX_CHAR_HEBREW, 0, 32);
   staticpro (&Vcharset_katakana_jisx0201);
   Vcharset_katakana_jisx0201 =
-    make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201,
-		  CHARSET_TYPE_94, 1, 1, 'I',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
+		  1, 1, 'I', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JISX0201 Kana"),
 		  build_string ("JISX0201.1976 (Japanese Kana)"),
 		  build_string ("JISX0201.1976 Japanese Kana"),
@@ -2833,9 +3376,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_latin_jisx0201);
   Vcharset_latin_jisx0201 =
-    make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201,
-		  CHARSET_TYPE_94, 1, 0, 'J',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
+		  1, 0, 'J', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JISX0201 Roman"),
 		  build_string ("JISX0201.1976 (Japanese Roman)"),
 		  build_string ("JISX0201.1976 Japanese Roman"),
@@ -2843,19 +3385,19 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_cyrillic_iso8859_5);
   Vcharset_cyrillic_iso8859_5 =
-    make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5,
-		  CHARSET_TYPE_96, 1, 1, 'L',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
+		  1, 1, 'L', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("ISO8859-5"),
 		  build_string ("ISO8859-5 (Cyrillic)"),
 		  build_string ("ISO8859-5 (Cyrillic)"),
 		  build_string ("iso8859-5"),
-		  Qnil, MIN_CHAR_CYRILLIC, MAX_CHAR_CYRILLIC, 0, 32);
+		  Qnil,
+		  0 /* MIN_CHAR_CYRILLIC */,
+		  0 /* MAX_CHAR_CYRILLIC */, 0, 32);
   staticpro (&Vcharset_latin_iso8859_9);
   Vcharset_latin_iso8859_9 =
-    make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9,
-		  CHARSET_TYPE_96, 1, 1, 'M',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
+		  1, 1, 'M', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Latin-5"),
 		  build_string ("ISO8859-9 (Latin-5)"),
 		  build_string ("ISO8859-9 (Latin-5)"),
@@ -2863,9 +3405,9 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_japanese_jisx0208_1978);
   Vcharset_japanese_jisx0208_1978 =
-    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978,
-		  CHARSET_TYPE_94X94, 2, 0, '@',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
+		  Qjapanese_jisx0208_1978, 94, 2,
+		  2, 0, '@', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JIS X0208:1978"),
 		  build_string ("JIS X0208:1978 (Japanese)"),
 		  build_string
@@ -2874,9 +3416,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_chinese_gb2312);
   Vcharset_chinese_gb2312 =
-    make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312,
-		  CHARSET_TYPE_94X94, 2, 0, 'A',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
+		  2, 0, 'A', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("GB2312"),
 		  build_string ("GB2312)"),
 		  build_string ("GB2312 Chinese simplified"),
@@ -2884,9 +3425,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_japanese_jisx0208);
   Vcharset_japanese_jisx0208 =
-    make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208,
-		  CHARSET_TYPE_94X94, 2, 0, 'B',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2,
+		  2, 0, 'B', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JISX0208"),
 		  build_string ("JIS X0208:1983 (Japanese)"),
 		  build_string ("JIS X0208:1983 Japanese Kanji"),
@@ -2896,9 +3436,8 @@ complex_vars_of_mule_charset (void)
   staticpro (&Vcharset_japanese_jisx0208_1990);
   Vcharset_japanese_jisx0208_1990 =
     make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990,
-		  Qjapanese_jisx0208_1990,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+		  Qjapanese_jisx0208_1990, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JISX0208-1990"),
 		  build_string ("JIS X0208:1990 (Japanese)"),
 		  build_string ("JIS X0208:1990 Japanese Kanji"),
@@ -2909,9 +3448,8 @@ complex_vars_of_mule_charset (void)
 #endif
   staticpro (&Vcharset_korean_ksc5601);
   Vcharset_korean_ksc5601 =
-    make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601,
-		  CHARSET_TYPE_94X94, 2, 0, 'C',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 94, 2,
+		  2, 0, 'C', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("KSC5601"),
 		  build_string ("KSC5601 (Korean"),
 		  build_string ("KSC5601 Korean Hangul and Hanja"),
@@ -2919,9 +3457,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_japanese_jisx0212);
   Vcharset_japanese_jisx0212 =
-    make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212,
-		  CHARSET_TYPE_94X94, 2, 0, 'D',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
+		  2, 0, 'D', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("JISX0212"),
 		  build_string ("JISX0212 (Japanese)"),
 		  build_string ("JISX0212 Japanese Supplement"),
@@ -2931,9 +3468,8 @@ complex_vars_of_mule_charset (void)
 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
   staticpro (&Vcharset_chinese_cns11643_1);
   Vcharset_chinese_cns11643_1 =
-    make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1,
-		  CHARSET_TYPE_94X94, 2, 0, 'G',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 94, 2,
+		  2, 0, 'G', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("CNS11643-1"),
 		  build_string ("CNS11643-1 (Chinese traditional)"),
 		  build_string
@@ -2942,9 +3478,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_chinese_cns11643_2);
   Vcharset_chinese_cns11643_2 =
-    make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2,
-		  CHARSET_TYPE_94X94, 2, 0, 'H',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
+		  2, 0, 'H', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("CNS11643-2"),
 		  build_string ("CNS11643-2 (Chinese traditional)"),
 		  build_string
@@ -2952,11 +3487,19 @@ complex_vars_of_mule_charset (void)
 		  build_string (CHINESE_CNS_PLANE_RE("2")),
 		  Qnil, 0, 0, 0, 33);
 #ifdef UTF2000
+  staticpro (&Vcharset_latin_tcvn5712);
+  Vcharset_latin_tcvn5712 =
+    make_charset (LEADING_BYTE_LATIN_TCVN5712, Qlatin_tcvn5712, 96, 1,
+		  1, 1, 'Z', CHARSET_LEFT_TO_RIGHT,
+		  build_string ("TCVN 5712"),
+		  build_string ("TCVN 5712 (VSCII-2)"),
+		  build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
+		  build_string ("tcvn5712-1"),
+		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_latin_viscii_lower);
   Vcharset_latin_viscii_lower =
-    make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower,
-		  CHARSET_TYPE_96, 1, 1, '1',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
+		  1, 1, '1', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("VISCII lower"),
 		  build_string ("VISCII lower (Vietnamese)"),
 		  build_string ("VISCII lower (Vietnamese)"),
@@ -2964,9 +3507,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_latin_viscii_upper);
   Vcharset_latin_viscii_upper =
-    make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper,
-		  CHARSET_TYPE_96, 1, 1, '2',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
+		  1, 1, '2', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("VISCII upper"),
 		  build_string ("VISCII upper (Vietnamese)"),
 		  build_string ("VISCII upper (Vietnamese)"),
@@ -2974,9 +3516,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 32);
   staticpro (&Vcharset_latin_viscii);
   Vcharset_latin_viscii =
-    make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii,
-		  CHARSET_TYPE_256, 1, 2, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
+		  1, 2, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("VISCII"),
 		  build_string ("VISCII 1.1 (Vietnamese)"),
 		  build_string ("VISCII 1.1 (Vietnamese)"),
@@ -2984,19 +3525,26 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 0);
   staticpro (&Vcharset_ideograph_daikanwa);
   Vcharset_ideograph_daikanwa =
-    make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa,
-		  CHARSET_TYPE_256X256, 2, 2, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2,
+		  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_pj_1);
   Vcharset_mojikyo_pj_1 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_1, Qmojikyo_pj_1, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-1"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 1"),
 		  build_string
@@ -3005,9 +3553,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_2);
   Vcharset_mojikyo_pj_2 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_2, Qmojikyo_pj_2, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-2"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 2"),
 		  build_string
@@ -3016,9 +3563,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_3);
   Vcharset_mojikyo_pj_3 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_3, Qmojikyo_pj_3, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-3"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 3"),
 		  build_string
@@ -3027,9 +3573,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_4);
   Vcharset_mojikyo_pj_4 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_4, Qmojikyo_pj_4, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-4"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 4"),
 		  build_string
@@ -3038,9 +3583,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_5);
   Vcharset_mojikyo_pj_5 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_5, Qmojikyo_pj_5, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-5"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 5"),
 		  build_string
@@ -3049,9 +3593,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_6);
   Vcharset_mojikyo_pj_6 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_6, Qmojikyo_pj_6, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-6"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 6"),
 		  build_string
@@ -3060,9 +3603,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_7);
   Vcharset_mojikyo_pj_7 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_7, Qmojikyo_pj_7, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-7"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 7"),
 		  build_string
@@ -3071,9 +3613,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_8);
   Vcharset_mojikyo_pj_8 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_8, Qmojikyo_pj_8, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-8"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 8"),
 		  build_string
@@ -3082,9 +3623,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_9);
   Vcharset_mojikyo_pj_9 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_9, Qmojikyo_pj_9, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-9"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 9"),
 		  build_string
@@ -3093,9 +3633,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_10);
   Vcharset_mojikyo_pj_10 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_10, Qmojikyo_pj_10, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-10"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 10"),
 		  build_string
@@ -3104,9 +3643,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_11);
   Vcharset_mojikyo_pj_11 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_11, Qmojikyo_pj_11, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-11"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 11"),
 		  build_string
@@ -3115,9 +3653,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_12);
   Vcharset_mojikyo_pj_12 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_12, Qmojikyo_pj_12, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-12"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 12"),
 		  build_string
@@ -3126,9 +3663,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_13);
   Vcharset_mojikyo_pj_13 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_13, Qmojikyo_pj_13, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-13"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 13"),
 		  build_string
@@ -3137,9 +3673,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_14);
   Vcharset_mojikyo_pj_14 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_14, Qmojikyo_pj_14, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-14"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 14"),
 		  build_string
@@ -3148,9 +3683,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_15);
   Vcharset_mojikyo_pj_15 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_15, Qmojikyo_pj_15, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-15"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 15"),
 		  build_string
@@ -3159,9 +3693,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_16);
   Vcharset_mojikyo_pj_16 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_16, Qmojikyo_pj_16, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-16"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 16"),
 		  build_string
@@ -3170,9 +3703,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_17);
   Vcharset_mojikyo_pj_17 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_17, Qmojikyo_pj_17, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-17"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 17"),
 		  build_string
@@ -3181,9 +3713,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_18);
   Vcharset_mojikyo_pj_18 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_18, Qmojikyo_pj_18, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-18"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 18"),
 		  build_string
@@ -3192,9 +3723,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_19);
   Vcharset_mojikyo_pj_19 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_19, Qmojikyo_pj_19, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-19"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 19"),
 		  build_string
@@ -3203,9 +3733,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_20);
   Vcharset_mojikyo_pj_20 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_20, Qmojikyo_pj_20, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-20"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 20"),
 		  build_string
@@ -3214,9 +3743,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_mojikyo_pj_21);
   Vcharset_mojikyo_pj_21 =
-    make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21,
-		  CHARSET_TYPE_94X94, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_21, Qmojikyo_pj_21, 94, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Mojikyo-PJ-21"),
 		  build_string ("Mojikyo (pseudo JIS encoding) part 21"),
 		  build_string
@@ -3225,9 +3753,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_ethiopic_ucs);
   Vcharset_ethiopic_ucs =
-    make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs,
-		  CHARSET_TYPE_256X256, 2, 2, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,
+		  2, 2, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Ethiopic (UCS)"),
 		  build_string ("Ethiopic (UCS)"),
 		  build_string ("Ethiopic of UCS"),
@@ -3236,9 +3763,8 @@ complex_vars_of_mule_charset (void)
 #endif
   staticpro (&Vcharset_chinese_big5_1);
   Vcharset_chinese_big5_1 =
-    make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1,
-		  CHARSET_TYPE_94X94, 2, 0, '0',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2,
+		  2, 0, '0', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Big5"),
 		  build_string ("Big5 (Level-1)"),
 		  build_string
@@ -3247,9 +3773,8 @@ complex_vars_of_mule_charset (void)
 		  Qnil, 0, 0, 0, 33);
   staticpro (&Vcharset_chinese_big5_2);
   Vcharset_chinese_big5_2 =
-    make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2,
-		  CHARSET_TYPE_94X94, 2, 0, '1',
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
+		  2, 0, '1', CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Big5"),
 		  build_string ("Big5 (Level-2)"),
 		  build_string
@@ -3263,9 +3788,8 @@ complex_vars_of_mule_charset (void)
      room, esp. as we don't yet recycle numbers. */
   staticpro (&Vcharset_composite);
   Vcharset_composite =
-    make_charset (LEADING_BYTE_COMPOSITE, Qcomposite,
-		  CHARSET_TYPE_96X96, 2, 0, 0,
-		  CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2,
+		  2, 0, 0, CHARSET_LEFT_TO_RIGHT,
 		  build_string ("Composite"),
 		  build_string ("Composite characters"),
 		  build_string ("Composite characters"),