X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=6f89233c62c03b88769cadb1e82b53fa94883345;hb=c055fb9d54088bf2dff25f6be1a033ff0cea5f92;hp=a112c8c50df77f4c4845b4d707239fd2d02a5a93;hpb=f44540086f484816ff3e77cf7a8f223b45355cdb;p=chise%2Fxemacs-chise.git-

diff --git a/src/mule-charset.c b/src/mule-charset.c
index a112c8c..6f89233 100644
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -62,8 +62,8 @@ Lisp_Object Vcharset_ucs_bmp;
 Lisp_Object Vcharset_latin_viscii;
 Lisp_Object Vcharset_latin_viscii_lower;
 Lisp_Object Vcharset_latin_viscii_upper;
-Lisp_Object Vcharset_hiragana_jisx0208;
-Lisp_Object Vcharset_katakana_jisx0208;
+Lisp_Object Vcharset_ideograph_daikanwa;
+Lisp_Object Vcharset_ethiopic_ucs;
 #endif
 Lisp_Object Vcharset_chinese_big5_1;
 Lisp_Object Vcharset_chinese_big5_2;
@@ -295,60 +295,62 @@ copy_char_code_table (Lisp_Object entry)
 Lisp_Object
 get_char_code_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_Object ret = cpt->property [ch >> 24];
+  Lisp_Object ret = cpt->property [(unsigned char)(code >> 24)];
 
   if (CHAR_BYTE_TABLE_P (ret))
     cpt = XCHAR_BYTE_TABLE (ret);
   else
     return ret;
 
-  ret = cpt->property [(unsigned char) (ch >> 16)];
+  ret = cpt->property [(unsigned char) (code >> 16)];
   if (CHAR_BYTE_TABLE_P (ret))
     cpt = XCHAR_BYTE_TABLE (ret);
   else
     return ret;
 
-  ret = cpt->property [(unsigned char) (ch >> 8)];
+  ret = cpt->property [(unsigned char) (code >> 8)];
   if (CHAR_BYTE_TABLE_P (ret))
     cpt = XCHAR_BYTE_TABLE (ret);
   else
     return ret;
   
-  return cpt->property [(unsigned char) ch];
+  return cpt->property [(unsigned char) code];
 }
 
 void
 put_char_code_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_Object ret = cpt1->property[ch >> 24];
+  Lisp_Object ret = cpt1->property[(unsigned char)(code >> 24)];
 
   if (CHAR_BYTE_TABLE_P (ret))
     {
       struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret);
       
-      ret = cpt2->property[(unsigned char)(ch >> 16)];
+      ret = cpt2->property[(unsigned char)(code >> 16)];
       if (CHAR_BYTE_TABLE_P (ret))
 	{
 	  struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret);
 	  
-	  ret = cpt3->property[(unsigned char)(ch >> 8)];
+	  ret = cpt3->property[(unsigned char)(code >> 8)];
 	  if (CHAR_BYTE_TABLE_P (ret))
 	    {
 	      struct Lisp_Char_Byte_Table* cpt4
 		= XCHAR_BYTE_TABLE (ret);
 	      
-	      cpt4->property[(unsigned char)ch] = value;
+	      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)ch] = value;
-	      cpt3->property[(unsigned char)(ch >> 8)] = cpt4;
+	      XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
+	      cpt3->property[(unsigned char)(code >> 8)] = cpt4;
 	    }
 	}
       else if (!EQ (ret, value))
@@ -356,10 +358,10 @@ put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table)
 	  Lisp_Object cpt3 = make_char_byte_table (ret);
 	  Lisp_Object cpt4 = make_char_byte_table (ret);
 	  
-	  XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)ch] = value;
-	  XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(ch >> 8)]
+	  XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)code] = value;
+	  XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(code >> 8)]
 	    = cpt4;
-	  cpt2->property[(unsigned char)(ch >> 16)] = cpt3;
+	  cpt2->property[(unsigned char)(code >> 16)] = cpt3;
 	}
     }
   else if (!EQ (ret, value))
@@ -368,22 +370,114 @@ put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table)
       Lisp_Object cpt3 = make_char_byte_table (ret);
       Lisp_Object cpt4 = make_char_byte_table (ret);
       
-      XCHAR_BYTE_TABLE(cpt4)->property[(unsigned char)ch] = value;
-      XCHAR_BYTE_TABLE(cpt3)->property[(unsigned char)(ch >>  8)] = cpt4;
-      XCHAR_BYTE_TABLE(cpt2)->property[(unsigned char)(ch >> 16)] = cpt3;
-      cpt1->property[(unsigned char)(ch >> 24)] = cpt2;
+      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;
+      cpt1->property[(unsigned char)(code >> 24)] = cpt2;
     }
 }
 
 
 Lisp_Object Vcharacter_attribute_table;
+Lisp_Object Vcharacter_composition_table;
+Lisp_Object Vcharacter_variant_table;
+
+Lisp_Object Q_decomposition;
+Lisp_Object Q_ucs;
+Lisp_Object Qcompat;
+Lisp_Object QnoBreak;
+Lisp_Object Qfraction;
+Lisp_Object Qsuper;
+Lisp_Object Qsub;
+Lisp_Object Qcircle;
+Lisp_Object Qsquare;
+Lisp_Object Qwide;
+Lisp_Object Qnarrow;
+Lisp_Object Qfont;
+
+Emchar
+to_char_code (Lisp_Object v, char* err_msg, Lisp_Object err_arg)
+{
+  if (INTP (v))
+    return XINT (v);
+  if (CHARP (v))
+    return XCHAR (v);
+  else if (EQ (v, Qcompat))
+    return -1;
+  else if (EQ (v, QnoBreak))
+    return -2;
+  else if (EQ (v, Qfraction))
+    return -3;
+  else if (EQ (v, Qsuper))
+    return -4;
+  else if (EQ (v, Qsub))
+    return -5;
+  else if (EQ (v, Qcircle))
+    return -6;
+  else if (EQ (v, Qsquare))
+    return -7;
+  else if (EQ (v, Qwide))
+    return -8;
+  else if (EQ (v, Qnarrow))
+    return -9;
+  else if (EQ (v, Qfont))
+    return -10;
+  else 
+    signal_simple_error (err_msg, err_arg);
+}
+
+DEFUN ("get-composite-char", Fget_composite_char, 1, 1, 0, /*
+Return character corresponding with list.
+*/
+       (list))
+{
+  Lisp_Object table = Vcharacter_composition_table;
+  Lisp_Object rest = list;
+
+  while (CONSP (rest))
+    {
+      Lisp_Object v = Fcar (rest);
+      Lisp_Object ret;
+      Emchar c = to_char_code (v, "Invalid value for composition", list);
+
+      ret = get_char_code_table (c, table);
+
+      rest = Fcdr (rest);
+      if (NILP (rest))
+	{
+	  if (!CHAR_CODE_TABLE_P (ret))
+	    return ret;
+	  else
+	    return Qt;
+	}
+      else if (!CONSP (rest))
+	break;
+      else if (CHAR_CODE_TABLE_P (ret))
+	table = ret;
+      else
+	signal_simple_error ("Invalid table is found with", list);
+    }
+  signal_simple_error ("Invalid value for composition", list);
+}
+
+DEFUN ("char-variants", Fchar_variants, 1, 1, 0, /*
+Return variants of CHARACTER.
+*/
+       (character))
+{
+  CHECK_CHAR (character);
+  return Fcopy_list (get_char_code_table (XCHAR (character),
+					  Vcharacter_variant_table));
+}
 
 DEFUN ("char-attribute-alist", Fchar_attribute_alist, 1, 1, 0, /*
 Return the alist of attributes of CHARACTER.
 */
        (character))
 {
-  return get_char_code_table (XCHAR (character), Vcharacter_attribute_table);
+  CHECK_CHAR (character);
+  return Fcopy_alist (get_char_code_table (XCHAR (character),
+					   Vcharacter_attribute_table));
 }
 
 DEFUN ("get-char-attribute", Fget_char_attribute, 2, 2, 0, /*
@@ -391,10 +485,12 @@ Return the value of CHARACTER's ATTRIBUTE.
 */
        (character, attribute))
 {
-  Lisp_Object ret
-    = get_char_code_table (XCHAR (character), Vcharacter_attribute_table);
+  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;
 
@@ -434,6 +530,7 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 {
   Lisp_Object ccs;
 
+  CHECK_CHAR (character);
   ccs = Ffind_charset (attribute);
   if (!NILP (ccs))
     {
@@ -481,6 +578,8 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 	  XCHARSET_DECODING_TABLE (ccs) = v = make_vector (ccs_len, Qnil);
 	}
 
+      if (XCHARSET_GRAPHIC (ccs) == 1)
+	value = Fcopy_list (value);
       rest = value;
       i = -1;
       while (CONSP (rest))
@@ -488,9 +587,16 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 	  Lisp_Object ei = Fcar (rest);
 	  
 	  if (!INTP (ei))
-	    signal_simple_error ("Invalid value for coded-charset",
-				 value);
-	  i = XINT (ei) - XCHARSET_BYTE_OFFSET (ccs);
+	    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))
@@ -506,11 +612,64 @@ Store CHARACTER's ATTRIBUTE with VALUE.
 	}
       XVECTOR_DATA(v)[i] = character;
     }
+  else if (EQ (attribute, Q_decomposition))
+    {
+      Lisp_Object rest = value;
+      Lisp_Object table = Vcharacter_composition_table;
+
+      if (!CONSP (value))
+	signal_simple_error ("Invalid value for ->decomposition",
+			     value);
+
+      while (CONSP (rest))
+	{
+	  Lisp_Object v = Fcar (rest);
+	  Lisp_Object ntable;
+	  Emchar c
+	    = to_char_code (v, "Invalid value for ->decomposition", value);
+
+	  rest = Fcdr (rest);
+	  if (!CONSP (rest))
+	    {
+	      put_char_code_table (c, character, table);
+	      break;
+	    }
+	  else
+	    {
+	      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;
+	    }
+	}
+    }
+  else if (EQ (attribute, Q_ucs))
+    {
+      Lisp_Object ret;
+      Emchar c;
+
+      if (!INTP (value))
+	signal_simple_error ("Invalid value for ->ucs", value);
+
+      c = XINT (value);
+
+      ret = get_char_code_table (c, Vcharacter_variant_table);
+      if (NILP (Fmemq (character, ret)))
+	{
+	  put_char_code_table (c, Fcons (character, ret),
+			       Vcharacter_variant_table);
+	}
+    }
   return put_char_attribute (character, attribute, value);
 }
 
 Lisp_Object Qucs;
 
+EXFUN (Fmake_char, 3);
+
 DEFUN ("define-char", Fdefine_char, 1, 1, 0, /*
 Store character's ATTRIBUTES.
 */
@@ -529,67 +688,11 @@ Store character's ATTRIBUTES.
 
 	  if (!LISTP (cell))
 	    signal_simple_error ("Invalid argument", attributes);
-	  if (!NILP (ccs = Ffind_charset (Fcar (cell)))
-	      && XCHARSET_FINAL (ccs))
+	  if (!NILP (ccs = Ffind_charset (Fcar (cell))))
 	    {
-	      Emchar code;
-
-	      if (XCHARSET_DIMENSION (ccs) == 1)
-		{
-		  Lisp_Object eb1 = Fcar (Fcdr (cell));
-		  int b1;
-
-		  if (!INTP (eb1))
-		    signal_simple_error ("Invalid argument", attributes);
-		  b1 = XINT (eb1);
-		  switch (XCHARSET_CHARS (ccs))
-		    {
-		    case 94:
-		      code = MIN_CHAR_94
-			+ (XCHARSET_FINAL (ccs) - '0') * 94 + (b1 - 33);
-		      break;
-		    case 96:
-		      code = MIN_CHAR_96
-			+ (XCHARSET_FINAL (ccs) - '0') * 96 + (b1 - 32);
-		      break;
-		    default:
-		      abort ();
-		    }
-		}
-	      else if (XCHARSET_DIMENSION (ccs) == 2)
-		{
-		  Lisp_Object eb1 = Fcar (Fcdr (cell));
-		  Lisp_Object eb2 = Fcar (Fcdr (Fcdr (cell)));
-		  int b1, b2;
-
-		  if (!INTP (eb1))
-		    signal_simple_error ("Invalid argument", attributes);
-		  b1 = XINT (eb1);
-		  if (!INTP (eb2))
-		    signal_simple_error ("Invalid argument", attributes);
-		  b2 = XINT (eb2);
-		  switch (XCHARSET_CHARS (ccs))
-		    {
-		    case 94:
-		      code = MIN_CHAR_94x94
-			+ (XCHARSET_FINAL (ccs) - '0') * 94 * 94
-			+ (b1 - 33) * 94 + (b2 - 33);
-		      break;
-		    case 96:
-		      code = MIN_CHAR_96x96
-			+ (XCHARSET_FINAL (ccs) - '0') * 96 * 96
-			+ (b1 - 32) * 96 + (b2 - 32);
-		      break;
-		    default:
-		      abort ();
-		    }
-		}
-	      else
-		{
-		  rest = Fcdr (rest);
-		  continue;
-		}
-	      character = make_char (code);
+	      cell = Fcdr (cell);
+	      character = Fmake_char (ccs, Fcar (cell),
+				      Fcar (Fcdr (cell)));
 	      goto setup_attributes;
 	    }
 	  rest = Fcdr (rest);
@@ -660,8 +763,8 @@ Lisp_Object Qascii,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
   Qvietnamese_viscii_upper,
-  Qhiragana_jisx0208,
-  Qkatakana_jisx0208,
+  Qideograph_daikanwa,
+  Qethiopic_ucs,
 #endif
   Qchinese_big5_1,
   Qchinese_big5_2,
@@ -1314,7 +1417,8 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 			      + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
 		   >= 0)
 		  && (d < 94 * 94))
-		return list2 ((d / 94) + 33, d % 94 + 33);
+		return list2 (make_int ((d / 94) + 33),
+			      make_int (d % 94 + 33));
 	    }
 	  else if (XCHARSET_CHARS (charset) == 96)
 	    {
@@ -1322,7 +1426,8 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 			      + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
 		   >= 0)
 		  && (d < 96 * 96))
-		return list2 ((d / 96) + 32, d % 96 + 32);
+		return list2 (make_int ((d / 96) + 32),
+			      make_int (d % 96 + 32));
 	    }
 	}
     }
@@ -1330,6 +1435,108 @@ range_charset_code_point (Lisp_Object charset, Emchar ch)
 }
 
 Lisp_Object
+split_builtin_char (Emchar c)
+{
+  if (c < MIN_CHAR_OBS_94x94)
+    {
+      if (c <= MAX_CHAR_BASIC_LATIN)
+	{
+	  return list2 (Vcharset_ascii, make_int (c));
+	}
+      else if (c < 0xA0)
+	{
+	  return list2 (Vcharset_control_1, make_int (c & 0x7F));
+	}
+      else if (c <= 0xff)
+	{
+	  return list2 (Vcharset_latin_iso8859_1, make_int (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));
+	}
+      else if ((MIN_CHAR_CYRILLIC <= c) && (c <= MAX_CHAR_CYRILLIC))
+	{
+	  return list2 (Vcharset_cyrillic_iso8859_5,
+			make_int (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));
+	}
+      else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
+	{
+	  return list2 (Vcharset_thai_tis620,
+			make_int (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
+	{
+	  return list3 (Vcharset_ucs_bmp,
+			make_int (c >> 8), make_int (c & 0xff));
+	}
+    }
+  else if (c <= MAX_CHAR_OBS_94x94)
+    {
+      return list3 (CHARSET_BY_ATTRIBUTES
+		    (CHARSET_TYPE_94X94,
+		     ((c - MIN_CHAR_OBS_94x94) / (94 * 94)) + '@',
+		     CHARSET_LEFT_TO_RIGHT),
+		    make_int ((((c - MIN_CHAR_OBS_94x94) / 94) % 94) + 33),
+		    make_int (((c - MIN_CHAR_OBS_94x94) % 94) + 33));
+    }
+  else if (c <= MAX_CHAR_DAIKANWA)
+    {
+      return list3 (Vcharset_ideograph_daikanwa,
+		    make_int ((c - MIN_CHAR_DAIKANWA) >> 8),
+		    make_int ((c - MIN_CHAR_DAIKANWA) & 255));
+    }
+  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));
+    }
+  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));
+    }
+  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));
+    }
+  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));
+    }
+  else
+    {
+      return Qnil;
+    }
+}
+
+Lisp_Object
 charset_code_point (Lisp_Object charset, Emchar ch)
 {
   Lisp_Object cdef = get_char_code_table (ch, Vcharacter_attribute_table);
@@ -1928,7 +2135,16 @@ Set mapping-table of CHARSET to TABLE.
     }
   else if (VECTORP (table))
     {
-      if (XVECTOR_LENGTH (table) > CHARSET_CHARS (cs))
+      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;
@@ -2070,6 +2286,18 @@ 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;
@@ -2090,8 +2318,8 @@ Return list of charset and one or two position-codes of CHAR.
       rc = list2 (XCHARSET_NAME (charset), make_int (c1));
     }
   UNGCPRO;
-
   return rc;
+#endif
 }
 
 
@@ -2199,6 +2427,8 @@ syms_of_mule_charset (void)
   DEFSUBR (Fget_char_attribute);
   DEFSUBR (Fput_char_attribute);
   DEFSUBR (Fdefine_char);
+  DEFSUBR (Fchar_variants);
+  DEFSUBR (Fget_composite_char);
   DEFSUBR (Fcharset_mapping_table);
   DEFSUBR (Fset_charset_mapping_table);
 #endif
@@ -2248,6 +2478,18 @@ syms_of_mule_charset (void)
   defsymbol (&Qchinese_cns11643_1,	"chinese-cns11643-1");
   defsymbol (&Qchinese_cns11643_2,	"chinese-cns11643-2");
 #ifdef UTF2000
+  defsymbol (&Q_ucs,			"->ucs");
+  defsymbol (&Q_decomposition,		"->decomposition");
+  defsymbol (&Qcompat,			"compat");
+  defsymbol (&QnoBreak,			"noBreak");
+  defsymbol (&Qfraction,		"fraction");
+  defsymbol (&Qsuper,			"super");
+  defsymbol (&Qsub,			"sub");
+  defsymbol (&Qcircle,			"circle");
+  defsymbol (&Qsquare,			"square");
+  defsymbol (&Qwide,			"wide");
+  defsymbol (&Qnarrow,			"narrow");
+  defsymbol (&Qfont,			"font");
   defsymbol (&Qucs,			"ucs");
   defsymbol (&Qucs_bmp,			"ucs-bmp");
   defsymbol (&Qlatin_viscii,		"latin-viscii");
@@ -2255,8 +2497,8 @@ syms_of_mule_charset (void)
   defsymbol (&Qlatin_viscii_upper,	"latin-viscii-upper");
   defsymbol (&Qvietnamese_viscii_lower,	"vietnamese-viscii-lower");
   defsymbol (&Qvietnamese_viscii_upper,	"vietnamese-viscii-upper");
-  defsymbol (&Qhiragana_jisx0208, 	"hiragana-jisx0208");
-  defsymbol (&Qkatakana_jisx0208, 	"katakana-jisx0208");
+  defsymbol (&Qideograph_daikanwa,	"ideograph-daikanwa");
+  defsymbol (&Qethiopic_ucs,		"ethiopic-ucs");
 #endif
   defsymbol (&Qchinese_big5_1,		"chinese-big5-1");
   defsymbol (&Qchinese_big5_2,		"chinese-big5-2");
@@ -2313,6 +2555,12 @@ 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);
+
+  staticpro (&Vcharacter_variant_table);
+  Vcharacter_variant_table = make_char_code_table (Qnil);
+
   Vdefault_coded_charset_priority_list = Qnil;
   DEFVAR_LISP ("default-coded-charset-priority-list",
 	       &Vdefault_coded_charset_priority_list /*
@@ -2577,26 +2825,24 @@ complex_vars_of_mule_charset (void)
 		  build_string ("VISCII 1.1 (Vietnamese)"),
 		  build_string ("VISCII1\\.1"),
 		  Qnil, 0, 0, 0, 0);
-  Vcharset_hiragana_jisx0208 =
-    make_charset (LEADING_BYTE_HIRAGANA_JISX0208, Qhiragana_jisx0208,
-		  CHARSET_TYPE_94X94, 2, 0, 'B',
+  Vcharset_ideograph_daikanwa =
+    make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa,
+		  CHARSET_TYPE_256X256, 2, 2, 0,
 		  CHARSET_LEFT_TO_RIGHT,
-		  build_string ("Hiragana"),
-		  build_string ("Hiragana of JIS X0208"),
-		  build_string ("Japanese Hiragana of JIS X0208"),
-		  build_string ("jisx0208\\.19\\(78\\|83\\|90\\)"),
-		  Qnil, MIN_CHAR_HIRAGANA, MAX_CHAR_HIRAGANA,
-		  (0x24 - 33) * 94 + (0x21 - 33), 33);
-  Vcharset_katakana_jisx0208 =
-    make_charset (LEADING_BYTE_KATAKANA_JISX0208, Qkatakana_jisx0208,
-		  CHARSET_TYPE_94X94, 2, 0, 'B',
+		  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);
+  Vcharset_ethiopic_ucs =
+    make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs,
+		  CHARSET_TYPE_256X256, 2, 2, 0,
 		  CHARSET_LEFT_TO_RIGHT,
-		  build_string ("Katakana"),
-		  build_string ("Katakana of JIS X0208"),
-		  build_string ("Japanese Katakana of JIS X0208"),
-		  build_string ("jisx0208\\.19\\(78\\|83\\|90\\)"),
-		  Qnil, MIN_CHAR_KATAKANA, MAX_CHAR_KATAKANA,
-		  (0x25 - 33) * 94 + (0x21 - 33), 33);
+		  build_string ("Ethiopic (UCS)"),
+		  build_string ("Ethiopic (UCS)"),
+		  build_string ("Ethiopic of UCS"),
+		  build_string ("Ethiopic-Unicode"),
+		  Qnil, 0x1200, 0x137F, 0x1200, 0);
 #endif
   Vcharset_chinese_big5_1 =
     make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1,