X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=2db3cbcebfc59250dcea85a408b636e6f39276be;hb=3aca7317dd930beecbddba646284279744087e69;hp=593492e99c41938fba686161ba46230a7e78313a;hpb=6011eb38982421f6c0a99660ea56de101395f233;p=chise%2Fxemacs-chise.git-

diff --git a/src/mule-charset.c b/src/mule-charset.c
index 593492e..2db3cbc 100644
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -111,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
@@ -121,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
 };
 
@@ -160,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++)
@@ -173,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
@@ -198,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;
 
-  cte->table = make_char_byte_table (initval);
+  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);
 
-  XSETCHAR_CODE_TABLE (obj, cte);
+  cte->table = make_byte_table (initval, older);
+
+  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;
@@ -434,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);
@@ -489,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);
@@ -517,96 +535,155 @@ 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));
 }
 
-DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
-Return the alist of attributes of CHARACTER.
-*/
-       (character))
+
+/* 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
 {
-  CHECK_CHAR (character);
-  return Fcopy_alist (get_char_code_table (XCHAR (character),
-					   Vcharacter_attribute_table));
+  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 ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
-Return the value of CHARACTER's ATTRIBUTE.
+DEFUN ("char-attribute-list", Fchar_attribute_list, 0, 0, 0, /*
+Return the list of all existing character attributes except coded-charsets.
 */
-       (character, attribute))
+       ())
 {
-  Lisp_Object ret;
-  Lisp_Object ccs;
+  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;
+}
 
-  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;
+/* 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;
+};
 
-  return Fcdr (Fassq (attribute, ret));
+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;
 }
 
-Lisp_Object
-put_char_attribute (Lisp_Object character, Lisp_Object attribute,
-		    Lisp_Object value)
+DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
+Return the alist of attributes of CHARACTER.
+*/
+       (character))
 {
-  Emchar char_code = XCHAR (character);
-  Lisp_Object ret
-    = get_char_code_table (char_code, Vcharacter_attribute_table);
-  Lisp_Object cell;
+  Lisp_Object alist = Qnil;
+  int i;
 
-  cell = Fassq (attribute, ret);
+  CHECK_CHAR (character);
+  {
+    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;
+  }
 
-  if (NILP (cell))
-    {
-      ret = Fcons (Fcons (attribute, value), ret);
-    }
-  else if (!EQ (Fcdr (cell), value))
+  for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
     {
-      Fsetcdr (cell, value);
+      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);
+	    }
+	}
     }
-  put_char_code_table (char_code, ret, Vcharacter_attribute_table);
-  return ret;
+  return alist;
 }
 
-Lisp_Object
-remove_char_attribute (Lisp_Object character, Lisp_Object attribute)
+DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
+Return the value of CHARACTER's ATTRIBUTE.
+*/
+       (character, attribute))
 {
-  Emchar char_code = XCHAR (character);
-  Lisp_Object alist
-    = get_char_code_table (char_code, Vcharacter_attribute_table);
+  Lisp_Object ccs;
 
-  if (EQ (attribute, Fcar (Fcar (alist))))
+  CHECK_CHAR (character);
+  if (!NILP (ccs = Ffind_charset (attribute)))
     {
-      alist = Fcdr (alist);
+      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
     {
-      Lisp_Object pr = alist;
-      Lisp_Object r = Fcdr (alist);
-
-      while (!NILP (r))
+      Lisp_Object table = Fgethash (attribute,
+				    Vchar_attribute_hash_table,
+				    Qunbound);
+      if (!UNBOUNDP (table))
 	{
-	  if (EQ (attribute, Fcar (Fcar (r))))
-	    {
-	      XCDR (pr) = Fcdr (r);
-	      break;
-	    }
-	  pr = r;
-	  r = Fcdr (r);
+	  Lisp_Object ret = get_char_id_table (XCHAR (character), table);
+	  if (!UNBOUNDP (ret))
+	    return ret;
 	}
     }
-  put_char_code_table (char_code, alist, Vcharacter_attribute_table);
-  return alist;
+  return Qnil;
 }
 
-Lisp_Object Qucs;
-
 DEFUN ("put-char-attribute", Fput_char_attribute, 3, 3, 0, /*
 Store CHARACTER's ATTRIBUTE with VALUE.
 */
@@ -618,114 +695,12 @@ Store CHARACTER's ATTRIBUTE with VALUE.
   ccs = Ffind_charset (attribute);
   if (!NILP (ccs))
     {
-      if (!EQ (XCHARSET_NAME (ccs), Qucs)
-	  || (XCHAR (character) != XINT (value)))
-	{
-	  Lisp_Object cpos, rest;
-	  Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
-	  Lisp_Object nv;
-	  int i = -1;
-	  int ccs_len;
-	  int dim;
-	  int code_point;
-
-	  /* 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))
-	    {
-	      Lisp_Object ret = Fcar (value);
-
-	      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))
-		{
-		  int i;
-
-		  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);
-		  i = XINT (ret);
-		  if (XCHARSET_GRAPHIC (ccs) == 1)
-		    i &= 0x7F;
-		  code_point = (code_point << 8) | i;
-		  rest = Fcdr (rest);
-		}
-	      value = make_int (code_point);
-	    }
-	  else if (INTP (value))
-	    {
-	      if (XCHARSET_GRAPHIC (ccs) == 1)
-		value = make_int (XINT (value) & 0x7F7F7F7F);
-	    }
-	  else
-	    signal_simple_error ("Invalid value for coded-charset", value);
-
-	  attribute = ccs;
-	  cpos = Fget_char_attribute (character, attribute);
-	  if (VECTORP (v))
-	    {
-	      if (!NILP (cpos))
-		{
-		  dim = XCHARSET_DIMENSION (ccs);
-		  code_point = XINT (cpos);
-		  while (dim > 0)
-		    {
-		      dim--;
-		      i = ((code_point >> (8 * dim)) & 255)
-			- XCHARSET_BYTE_OFFSET (ccs);
-		      nv = XVECTOR_DATA(v)[i];
-		      if (!VECTORP (nv))
-			break;
-		      v = nv;
-		    }
-		  if (i >= 0)
-		    XVECTOR_DATA(v)[i] = Qnil;
-		  v = XCHARSET_DECODING_TABLE (ccs);
-		}
-	    }
-	  else
-	    {
-	      XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil);
-	    }
-
-	  dim = XCHARSET_DIMENSION (ccs);
-	  code_point = XINT (value);
-	  i = -1;
-	  while (dim > 0)
-	    {
-	      dim--;
-	      i = ((code_point >> (8 * dim)) & 255)
-		- XCHARSET_BYTE_OFFSET (ccs);
-	      nv = XVECTOR_DATA(v)[i];
-	      if (dim > 0)
-		{
-		  if (!VECTORP (nv))
-		    nv = (XVECTOR_DATA(v)[i] = make_vector (ccs_len, Qnil));
-		  v = nv;
-		}
-	      else
-		break;
-	    }
-	  XVECTOR_DATA(v)[i] = character;
-	}
-      else
-	attribute = ccs;
+      return put_char_ccs_code_point (character, ccs, value);
     }
   else if (EQ (attribute, Q_decomposition))
     {
+      Lisp_Object seq;
+
       if (!CONSP (value))
 	signal_simple_error ("Invalid value for ->decomposition",
 			     value);
@@ -734,28 +709,37 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 	{
 	  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))
 	    {
 	      Lisp_Object v = Fcar (rest);
 	      Lisp_Object ntable;
 	      Emchar c
-		= to_char_code (v,
-				"Invalid value for ->decomposition", value);
+		= 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_code_table (c, character, table);
+		  put_char_id_table (c, character, table);
 		  break;
 		}
 	      else
 		{
-		  ntable = get_char_code_table (c, table);
-		  if (!CHAR_CODE_TABLE_P (ntable))
+		  ntable = get_char_id_table (c, table);
+		  if (!CHAR_ID_TABLE_P (ntable))
 		    {
-		      ntable = make_char_code_table (Qnil);
-		      put_char_code_table (c, ntable, table);
+		      ntable
+			= make_char_id_table (Qnil, OLDER_RECORD_P (table));
+		      put_char_id_table (c, ntable, table);
 		    }
 		  table = ntable;
 		}
@@ -769,15 +753,17 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 	    {
 	      Emchar c = XINT (v);
 	      Lisp_Object ret
-		= get_char_code_table (c, Vcharacter_variant_table);
+		= get_char_id_table (c, Vcharacter_variant_table);
 
 	      if (NILP (Fmemq (v, ret)))
 		{
-		  put_char_code_table (c, Fcons (character, ret),
-				       Vcharacter_variant_table);
+		  put_char_id_table (c, Fcons (character, ret),
+				     Vcharacter_variant_table);
 		}
 	    }
+	  seq = make_vector (1, v);
 	}
+      value = seq;
     }
   else if (EQ (attribute, Q_ucs))
     {
@@ -789,14 +775,26 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 
       c = XINT (value);
 
-      ret = get_char_code_table (c, Vcharacter_variant_table);
+      ret = get_char_id_table (c, Vcharacter_variant_table);
       if (NILP (Fmemq (character, ret)))
 	{
-	  put_char_code_table (c, Fcons (character, ret),
-			       Vcharacter_variant_table);
+	  put_char_id_table (c, Fcons (character, ret),
+			     Vcharacter_variant_table);
 	}
     }
-  return put_char_attribute (character, attribute, value);
+  {
+    Lisp_Object table = Fgethash (attribute,
+				  Vchar_attribute_hash_table,
+				  Qnil);
+
+    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, /*
@@ -810,46 +808,221 @@ Remove CHARACTER's ATTRIBUTE.
   ccs = Ffind_charset (attribute);
   if (!NILP (ccs))
     {
-      Lisp_Object cpos;
-      Lisp_Object v = XCHARSET_DECODING_TABLE (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))
+	    {
+	      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;
-      int i = -1;
-      int ccs_len;
-      int dim;
+
+      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;
-	      
-      /* ad-hoc method for `ascii' */
-      if ((XCHARSET_CHARS (ccs) == 94) &&
-	  (XCHARSET_BYTE_OFFSET (ccs) != 33))
-	ccs_len = 128 - XCHARSET_BYTE_OFFSET (ccs);
+
+      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))
+	    {
+	      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
-	ccs_len = XCHARSET_CHARS (ccs);
+	signal_simple_error ("Invalid value for coded-charset", value);
 
-      attribute = ccs;
-      cpos = Fget_char_attribute (character, attribute);
       if (VECTORP (v))
 	{
+	  Lisp_Object cpos = Fget_char_attribute (character, ccs);
 	  if (!NILP (cpos))
 	    {
-	      dim = XCHARSET_DIMENSION (ccs);
-	      code_point = XINT (cpos);
-	      while (dim > 0)
-		{
-		  dim--;
-		  i = ((code_point >> (8 * dim)) & 255)
-		    - XCHARSET_BYTE_OFFSET (ccs);
-		  nv = XVECTOR_DATA(v)[i];
-		  if (!VECTORP (nv))
-		    break;
-		  v = nv;
-		}
-	      if (i >= 0)
-		XVECTOR_DATA(v)[i] = Qnil;
-	      v = XCHARSET_DECODING_TABLE (ccs);
+	      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);
     }
-  return remove_char_attribute (character, attribute);
+  if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
+    {
+      XCHARSET_ENCODING_TABLE (ccs)
+	= encoding_table = make_char_id_table (Qnil, -1);
+    }
+  put_char_id_table (XCHAR (character), value, encoding_table);
+  return Qt;
+}
+
+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);
+
+  if (VECTORP (decoding_table))
+    {
+      Lisp_Object cpos = Fget_char_attribute (character, ccs);
+
+      if (!NILP (cpos))
+	{
+	  decoding_table_remove_char (decoding_table,
+				      XCHARSET_DIMENSION (ccs),
+				      XCHARSET_BYTE_OFFSET (ccs),
+				      XINT (cpos));
+	}
+    }
+  if (CHAR_ID_TABLE_P (encoding_table))
+    {
+      put_char_id_table (XCHAR (character), Qnil, encoding_table);
+    }
+  return Qt;
 }
 
 EXFUN (Fmake_char, 3);
@@ -863,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))
     {
@@ -906,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;
@@ -962,7 +1163,6 @@ Lisp_Object Qascii,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
-  Qideograph_daikanwa,
   Qmojikyo,
   Qmojikyo_pj_1,
   Qmojikyo_pj_2,
@@ -995,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.
 
@@ -1112,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;
@@ -1268,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++;
@@ -1361,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);
@@ -1369,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;
 }
@@ -1377,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)
@@ -1407,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 }
 };
@@ -1417,7 +1618,7 @@ 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
@@ -1433,8 +1634,10 @@ make_charset (Charset_ID id, Lisp_Object name,
 {
   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;
@@ -1453,6 +1656,7 @@ 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;
@@ -1554,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
 
@@ -1778,11 +1982,18 @@ encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
       *charset = Vcharset_ucs;
       return c;
     }
+  /*
   else if (c <= MAX_CHAR_DAIKANWA)
     {
       *charset = Vcharset_ideograph_daikanwa;
       return c - MIN_CHAR_DAIKANWA;
     }
+  */
+  else if (c <= MAX_CHAR_MOJIKYO)
+    {
+      *charset = Vcharset_mojikyo;
+      return c - MIN_CHAR_MOJIKYO;
+    }
   else if (c < MIN_CHAR_94)
     {
       *charset = Vcharset_ucs;
@@ -1913,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;
 }
 
@@ -2158,7 +2369,7 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   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)))
@@ -2327,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);
@@ -2422,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:
@@ -2463,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,
-	       make_int (i + CHARSET_BYTE_OFFSET (cs)));
+	    put_char_ccs_code_point (c, charset,
+				     make_int (i + byte_offset));
 	}
       break;
     case 2:
@@ -2477,25 +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
+		    put_char_ccs_code_point
 		      (c, charset,
-		       make_int ( ((i + CHARSET_BYTE_OFFSET (cs)) << 8)
-				  | (j + CHARSET_BYTE_OFFSET (cs)) ));
+		       make_int ( ( (i + byte_offset) << 8 )
+				  | (j + byte_offset)
+				  ) );
 		}
 	    }
 	  else if (CHARP (v))
-	    put_char_attribute (v, charset,
-				make_int (i + CHARSET_BYTE_OFFSET (cs)));
+	    put_char_ccs_code_point (v, charset,
+				     make_int (i + byte_offset));
 	}
       break;
     }
@@ -2523,6 +2732,77 @@ Make a character from CHARSET and code-point CODE.
     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, /*
@@ -2533,7 +2813,7 @@ character s with caron.
 */
        (charset, arg1, arg2))
 {
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
   int a1, a2;
   int lowlim, highlim;
 
@@ -2744,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);
@@ -2763,6 +3049,7 @@ 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);
@@ -2776,6 +3063,7 @@ syms_of_mule_charset (void)
 
 #ifdef UTF2000
   DEFSUBR (Fdecode_char);
+  DEFSUBR (Fdecode_builtin_char);
 #endif
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
@@ -2910,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
@@ -2925,19 +3213,16 @@ Leading-code of private TYPE9N charset of column-width 1.
 #endif
 
 #ifdef UTF2000
-  Vutf_2000_version = build_string("0.15 (Sangō)");
+  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",
@@ -2958,6 +3243,10 @@ 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,