X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fmule-charset.c;h=c3d69deb9f743c12b515ea4d3b8e74af02d53c4d;hb=0680bf5c284a73aaa6e267c4b0f1363d2cb48739;hp=5d76821055588e94175b5f8f404ac86c4997e2c7;hpb=965a56e0f7857093cdc7f9024c5173e4471911f5;p=chise%2Fxemacs-chise.git-

diff --git a/src/mule-charset.c b/src/mule-charset.c
index 5d76821..c3d69de 100644
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -59,6 +59,7 @@ Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;
 #ifdef UTF2000
 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;
@@ -124,75 +125,186 @@ Bytecount rep_bytes_by_first_byte[0xA0] =
 #endif
 
 #ifdef UTF2000
-Emchar_to_byte_table*
-make_byte_from_character_table ()
+static Lisp_Object
+mark_char_byte_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
-  Emchar_to_byte_table* table
-    = (Emchar_to_byte_table*) xmalloc (sizeof (Emchar_to_byte_table));
+  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_TABLE (obj);
+  int i;
 
-  table->base = NULL;
-  return table;
+  for (i = 0; i < 256; i++)
+    {
+      markobj (cte->property[i]);
+    }
+  return Qnil;
 }
 
-#define destroy_byte_from_character_table(table)  xfree(table)
+static int
+char_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);
+  int i;
+
+  for (i = 0; i < 256; i++)
+    if (CHAR_BYTE_TABLE_P (cte1->property[i]))
+      {
+	if (CHAR_BYTE_TABLE_P (cte2->property[i]))
+	  {
+	    if (!char_byte_table_equal (cte1->property[i],
+					cte2->property[i], depth + 1))
+	      return 0;
+	  }
+	else
+	  return 0;
+      }
+    else
+      if (!internal_equal (cte1->property[i], cte2->property[i], depth + 1))
+	return 0;
+  return 1;
+}
 
-void
-put_byte_from_character_table (Emchar ch, unsigned char val,
-			       Emchar_to_byte_table* table)
+static unsigned long
+char_byte_table_hash (Lisp_Object obj, int depth)
 {
-  if (table->base == NULL)
+  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_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 },
+  { XD_END }
+};
+
+DEFINE_LRECORD_IMPLEMENTATION ("char-code-table", char_byte_table,
+                               mark_char_byte_table,
+			       internal_object_printer,
+			       0, char_byte_table_equal,
+			       char_byte_table_hash,
+			       char_byte_table_description,
+			       struct Lisp_Char_Byte_Table);
+
+
+static Lisp_Object
+make_char_byte_table (Lisp_Object initval)
+{
+  Lisp_Object obj;
+  int i;
+  struct Lisp_Char_Byte_Table *cte =
+    alloc_lcrecord_type (struct Lisp_Char_Byte_Table,
+			 &lrecord_char_byte_table);
+
+  for (i = 0; i < 256; i++)
+    cte->property[i] = initval;
+
+  XSETCHAR_BYTE_TABLE (obj, cte);
+  return obj;
+}
+
+static Lisp_Object
+copy_char_byte_table (Lisp_Object entry)
+{
+  struct Lisp_Char_Byte_Table *cte = XCHAR_BYTE_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);
+
+  for (i = 0; i < 256; i++)
     {
-      table->base = xmalloc (256);
-      table->offset = ch - (ch % 256);
-      table->size = 256;
-      table->base[ch - table->offset] = val;
+      Lisp_Object new = cte->property[i];
+      if (CHAR_BYTE_TABLE_P (new))
+	ctenew->property[i] = copy_char_byte_table (new);
+      else
+	ctenew->property[i] = new;
     }
+
+  XSETCHAR_BYTE_TABLE (obj, ctenew);
+  return obj;
+}
+
+#define make_char_code_table(initval) make_char_byte_table(initval)
+
+Lisp_Object
+get_char_code_table (Emchar ch, Lisp_Object table)
+{
+  struct Lisp_Char_Byte_Table* cpt = XCHAR_BYTE_TABLE (table);
+  Lisp_Object ret = cpt->property [ch >> 24];
+
+  if (CHAR_BYTE_TABLE_P (ret))
+    cpt = XCHAR_BYTE_TABLE (ret);
   else
-    {
-      int i = ch - table->offset;
+    return ret;
 
-      if (i < 0)
-	{
-	  size_t new_size = table->size - i;
-	  size_t j;
-
-	  new_size += 256 - (new_size % 256);
-	  table->base = xrealloc (table->base, new_size);
-      	  memmove (table->base + (new_size - table->size), table->base,
-		   table->size);
-	  for (j = 0; j < (new_size - table->size); j++)
-	    table->base[j] = 0;
-	  table->offset -= (new_size - table->size);
-	  table->base[ch - table->offset] = val;
-	  table->size = new_size;
-	}
-      else if (i >= table->size)
+  ret = cpt->property [(unsigned char) (ch >> 16)];
+  if (CHAR_BYTE_TABLE_P (ret))
+    cpt = XCHAR_BYTE_TABLE (ret);
+  else
+    return ret;
+
+  ret = cpt->property [(unsigned char) (ch >> 8)];
+  if (CHAR_BYTE_TABLE_P (ret))
+    cpt = XCHAR_BYTE_TABLE (ret);
+  else
+    return ret;
+  
+  return cpt->property [(unsigned char) ch];
+}
+
+void
+put_char_code_table (Emchar ch, Lisp_Object value, Lisp_Object table)
+{
+  struct Lisp_Char_Byte_Table* cpt1 = XCHAR_BYTE_TABLE (table);
+  Lisp_Object ret = cpt1->property[ch >> 24];
+
+  if (CHAR_BYTE_TABLE_P (ret))
+    {
+      struct Lisp_Char_Byte_Table* cpt2 = XCHAR_BYTE_TABLE (ret);
+      
+      ret = cpt2->property[(unsigned char)(ch >> 16)];
+      if (CHAR_BYTE_TABLE_P (ret))
 	{
-	  size_t new_size = i + 1;
-	  size_t j;
-
-	  new_size += 256 - (new_size % 256);
-	  table->base = xrealloc (table->base, new_size);
-      	  for (j = table->size; j < new_size; j++)
-	    table->base[j] = 0;
-	  table->base[i] = val;
-	  table->size = new_size;
+	  struct Lisp_Char_Byte_Table* cpt3 = XCHAR_BYTE_TABLE (ret);
+	  
+	  ret = cpt3->property[(unsigned char)(ch >> 8)];
+	  if (CHAR_BYTE_TABLE_P (ret))
+	    {
+	      struct Lisp_Char_Byte_Table* cpt4
+		= XCHAR_BYTE_TABLE (ret);
+	      
+	      cpt4->property[(unsigned char)ch] = 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;
+	    }
 	}
-      else
+      else if (!EQ (ret, value))
 	{
-      	  table->base[i] = val;
+	  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;
+	  cpt2->property[(unsigned char)(ch >> 16)] = cpt3;
 	}
     }
-}
-
-unsigned char
-get_byte_from_character_table (Emchar ch, Emchar_to_byte_table* table)
-{
-  size_t i = ch - table->offset;
-  if (i < table->size)
-    return table->base[i];
-  else
-    return 0;
+  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)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;
+    }
 }
 
 
@@ -235,6 +347,7 @@ Lisp_Object Qascii,
   Qchinese_cns11643_2,
 #ifdef UTF2000
   Qucs_bmp,
+  Qlatin_viscii,
   Qlatin_viscii_lower,
   Qlatin_viscii_upper,
   Qvietnamese_viscii_lower,
@@ -250,8 +363,12 @@ 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.
@@ -615,6 +732,7 @@ mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object))
   markobj (cs->ccl_program);
 #ifdef UTF2000
   markobj (cs->decoding_table);
+  markobj (cs->encoding_table);
 #endif
   return cs->name;
 }
@@ -655,6 +773,9 @@ 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 },
+#ifdef UTF2000
+  { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, decoding_table), 2 },
+#endif
   { XD_END }
 };
 
@@ -662,6 +783,7 @@ DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
                                mark_charset, print_charset, 0, 0, 0,
 			       charset_description,
 			       struct Lisp_Charset);
+
 /* Make a new charset. */
 
 static Lisp_Object
@@ -693,91 +815,48 @@ make_charset (Charset_ID id, Lisp_Object name,
   CHARSET_CCL_PROGRAM	(cs) = Qnil;
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
 #ifdef UTF2000
-  CHARSET_DECODING_TABLE(cs) = decoding_table;
+  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_TYPE (cs))
     {
     case CHARSET_TYPE_94:
       CHARSET_DIMENSION (cs) = 1;
       CHARSET_CHARS (cs) = 94;
-#ifdef UTF2000
-      if (!EQ (decoding_table, Qnil))
-	{
-	  size_t i;
-	  CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
-	  for (i = 0; i < 94; i++)
-	    {
-	      Lisp_Object c = XVECTOR_DATA(decoding_table)[i];
-
-	      if (!EQ (c, Qnil))
-		put_byte_from_character_table (XCHAR (c), i + 33,
-					       CHARSET_TO_BYTE1_TABLE(cs));
-	    }
-	}
-      else
-	CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
       break;
     case CHARSET_TYPE_96:
       CHARSET_DIMENSION (cs) = 1;
       CHARSET_CHARS (cs) = 96;
-#ifdef UTF2000
-      if (!EQ (decoding_table, Qnil))
-	{
-	  size_t i;
-	  CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
-	  for (i = 0; i < 96; i++)
-	    {
-	      Lisp_Object c = XVECTOR_DATA(decoding_table)[i];
-
-	      if (!EQ (c, Qnil))
-		put_byte_from_character_table (XCHAR (c), i + 32,
-					       CHARSET_TO_BYTE1_TABLE(cs));
-	    }
-	}
-      else
-	CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
       break;
     case CHARSET_TYPE_94X94:
       CHARSET_DIMENSION (cs) = 2;
       CHARSET_CHARS (cs) = 94;
-#ifdef UTF2000
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
       break;
     case CHARSET_TYPE_96X96:
       CHARSET_DIMENSION (cs) = 2;
       CHARSET_CHARS (cs) = 96;
-#ifdef UTF2000
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
       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;
-#ifdef UTF2000
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
+      break;
+    case CHARSET_TYPE_256:
+      CHARSET_DIMENSION (cs) = 1;
+      CHARSET_CHARS (cs) = 256;
       break;
     case CHARSET_TYPE_256X256:
       CHARSET_DIMENSION (cs) = 2;
       CHARSET_CHARS (cs) = 256;
-#ifdef UTF2000
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-#endif
       break;
 #endif
     }
@@ -828,6 +907,12 @@ get_unallocated_leading_byte (int dimension)
 {
   Charset_ID lb;
 
+#ifdef UTF2000
+  if (next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
+    lb = 0;
+  else
+    lb = next_allocated_leading_byte++;
+#else
   if (dimension == 1)
     {
       if (next_allocated_1_byte_leading_byte > MAX_LEADING_BYTE_PRIVATE_1)
@@ -842,6 +927,7 @@ get_unallocated_leading_byte (int dimension)
       else
 	lb = next_allocated_2_byte_leading_byte++;
     }
+#endif
 
   if (!lb)
     signal_simple_error
@@ -855,13 +941,29 @@ get_unallocated_leading_byte (int dimension)
 unsigned char
 charset_get_byte1 (Lisp_Object charset, Emchar ch)
 {
-  Emchar_to_byte_table* table;
+  Lisp_Object table;
   int d;
 
-  if ((table = XCHARSET_TO_BYTE1_TABLE (charset)) != NULL)
-    return get_byte_from_character_table (ch, table);
-  else if ((XCHARSET_UCS_MIN (charset) <= ch)
-	   && (ch <= XCHARSET_UCS_MAX (charset)))
+  if (!EQ (table = XCHARSET_ENCODING_TABLE (charset), Qnil))
+    {
+      Lisp_Object value = get_char_code_table (ch, table);
+
+      if (INTP (value))
+	{
+	  Emchar code = XINT (value);
+
+	  if (code < (1 << 8))
+	    return code;
+	  else if (code < (1 << 16))
+	    return code >> 8;
+	  else if (code < (1 << 24))
+	    return code >> 16;
+	  else
+	    return code >> 24;
+	}
+    }
+  if ((XCHARSET_UCS_MIN (charset) <= ch)
+      && (ch <= XCHARSET_UCS_MAX (charset)))
     return (ch - XCHARSET_UCS_MIN (charset)
 	    + XCHARSET_CODE_OFFSET (charset))
       / (XCHARSET_DIMENSION (charset) == 1 ?
@@ -927,12 +1029,26 @@ charset_get_byte2 (Lisp_Object charset, Emchar ch)
     return 0;
   else
     {
-      Emchar_to_byte_table* table;
+      Lisp_Object table;
 
-      if ((table = XCHARSET_TO_BYTE2_TABLE (charset)) != NULL)
-	return get_byte_from_character_table (ch, table);
-      else if ((XCHARSET_UCS_MIN (charset) <= ch)
-	       && (ch <= XCHARSET_UCS_MAX (charset)))
+      if (!EQ (table = XCHARSET_ENCODING_TABLE (charset), Qnil))
+	{
+	  Lisp_Object value = get_char_code_table (ch, table);
+	  
+	  if (INTP (value))
+	    {
+	      Emchar code = XINT (value);
+
+	      if (code < (1 << 16))
+		return (unsigned char)code;
+	      else if (code < (1 << 24))
+		return (unsigned char)(code >> 16);
+	      else
+		return (unsigned char)(code >> 24);
+	    }
+	}
+      if ((XCHARSET_UCS_MIN (charset) <= ch)
+	  && (ch <= XCHARSET_UCS_MAX (charset)))
 	return ((ch - XCHARSET_UCS_MIN (charset)
 		 + XCHARSET_CODE_OFFSET (charset))
 		/ (XCHARSET_DIMENSION (charset) == 2 ?
@@ -1108,6 +1224,10 @@ character set.  Recognized properties are:
   Lisp_Object rest, keyword, value;
   Lisp_Object ccl_program = Qnil;
   Lisp_Object short_name = Qnil, long_name = Qnil;
+#ifdef UTF2000
+  Emchar code_offset = 0;
+  unsigned char byte_offset = 0;
+#endif
 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))
@@ -1159,7 +1279,11 @@ character set.  Recognized properties are:
 	{
 	  CHECK_INT (value);
 	  graphic = XINT (value);
+#ifdef UTF2000
+	  if (graphic < 0 || graphic > 2)
+#else
 	  if (graphic < 0 || graphic > 1)
+#endif
 	    signal_simple_error ("Invalid value for 'graphic", value);
 	}
 
@@ -1219,12 +1343,17 @@ character set.  Recognized properties are:
     {
       if (chars == 94)
 	{
-	  /* id = CHARSET_ID_OFFSET_94 + final; */
-	  id = get_unallocated_leading_byte (dimension);
+	  if (code_offset == 0)
+	    id = CHARSET_ID_OFFSET_94 + final;
+	  else
+	    id = get_unallocated_leading_byte (dimension);
 	}
       else if (chars == 96)
 	{
-	  id = get_unallocated_leading_byte (dimension);
+	  if (code_offset == 0)
+	    id = CHARSET_ID_OFFSET_96 + final;
+	  else
+	    id = get_unallocated_leading_byte (dimension);
 	}
       else
 	{
@@ -1235,7 +1364,10 @@ character set.  Recognized properties are:
     {
       if (chars == 94)
 	{
-	  id = get_unallocated_leading_byte (dimension);
+	  if (code_offset == 0)
+	    id = CHARSET_ID_OFFSET_94x94 + final;
+	  else
+	    id = get_unallocated_leading_byte (dimension);
 	}
       else if (chars == 96)
 	{
@@ -1250,6 +1382,13 @@ character set.  Recognized properties are:
     {
       abort ();
     }
+  if (final)
+    {
+      if (chars == 94)
+	byte_offset = 33;
+      else if (chars == 96)
+	byte_offset = 32;
+    }
 #else
   id = get_unallocated_leading_byte (dimension);
 #endif
@@ -1271,7 +1410,7 @@ character set.  Recognized properties are:
   charset = make_charset (id, name, type, columns, graphic,
 			  final, direction, short_name, long_name,
 			  doc_string, registry,
-			  Qnil, 0, 0, 0, 0);
+			  Qnil, 0, 0, 0, byte_offset);
   if (!NILP (ccl_program))
     XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return charset;
@@ -1552,114 +1691,79 @@ Set mapping-table of CHARSET to TABLE.
        (charset, table))
 {
   struct Lisp_Charset *cs;
-  Emchar_to_byte_table* old_byte1_table;
-  Emchar_to_byte_table* old_byte2_table;
+  Lisp_Object old_table;
+  size_t i;
 
   charset = Fget_charset (charset);
-  CHECK_VECTOR (table);
-  
   cs = XCHARSET (charset);
-  CHARSET_DECODING_TABLE(cs) = table;
-  old_byte1_table = CHARSET_TO_BYTE1_TABLE(cs);
-  old_byte2_table = CHARSET_TO_BYTE2_TABLE(cs);
-  switch (CHARSET_TYPE (cs))
+
+  if (EQ (table, Qnil))
     {
-    case CHARSET_TYPE_94:
-      if (!EQ (table, Qnil))
-	{
-	  size_t i;
-	  CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
-	  for (i = 0; i < 94; i++)
-	    {
-	      Lisp_Object c = XVECTOR_DATA(table)[i];
+      CHARSET_DECODING_TABLE(cs) = table;
+      CHARSET_ENCODING_TABLE(cs) = Qnil;
+      return table;
+    }
+  else if (VECTORP (table))
+    {
+      if (XVECTOR_LENGTH (table) > CHARSET_CHARS (cs))
+	args_out_of_range (table, make_int (CHARSET_CHARS (cs)));
+      old_table = CHARSET_ENCODING_TABLE(cs);
+      CHARSET_DECODING_TABLE(cs) = table;
+    }
+  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); */
 
-	      if (!EQ (c, Qnil))
-		put_byte_from_character_table (XCHAR (c), i + 33,
-					       CHARSET_TO_BYTE1_TABLE(cs));
-	    }
-	}
-      else
-	CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-      break;
-    case CHARSET_TYPE_96:
-      if (!EQ (table, Qnil))
+  switch (CHARSET_DIMENSION (cs))
+    {
+    case 1:
+      CHARSET_ENCODING_TABLE(cs) = make_char_code_table (Qnil);
+      for (i = 0; i < XVECTOR_LENGTH (table); i++)
 	{
-	  size_t i;
-	  CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
-	  for (i = 0; i < 96; i++)
-	    {
-	      Lisp_Object c = XVECTOR_DATA(table)[i];
+	  Lisp_Object c = XVECTOR_DATA(table)[i];
 
-	      if (!EQ (c, Qnil))
-		put_byte_from_character_table (XCHAR (c), i + 32,
-					       CHARSET_TO_BYTE1_TABLE(cs));
-	    }
+	  if (CHARP (c))
+	    put_char_code_table (XCHAR (c),
+				 make_int (i + CHARSET_BYTE_OFFSET (cs)),
+				 CHARSET_ENCODING_TABLE(cs));
 	}
-      else
-	CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
       break;
-    case CHARSET_TYPE_94X94:
-      if (!EQ (table, Qnil))
+    case 2:
+      CHARSET_ENCODING_TABLE(cs) = make_char_code_table (Qnil);
+      for (i = 0; i < XVECTOR_LENGTH (table); i++)
 	{
-	  size_t i;
+	  Lisp_Object v = XVECTOR_DATA(table)[i];
 
-	  CHARSET_TO_BYTE1_TABLE(cs) = make_byte_from_character_table();
-	  CHARSET_TO_BYTE2_TABLE(cs) = make_byte_from_character_table();
-	  for (i = 0; i < XVECTOR_LENGTH (table); i++)
+	  if (VECTORP (v))
 	    {
-	      Lisp_Object v = XVECTOR_DATA(table)[i];
+	      size_t j;
 
-	      if (VECTORP (v))
+	      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++)
 		{
-		  size_t j;
-
-		  for (j = 0; j < XVECTOR_LENGTH (v); j++)
-		    {
-		      Lisp_Object c = XVECTOR_DATA(v)[j];
-
-		      if (!EQ (c, Qnil))
-			{
-			  put_byte_from_character_table
-			    (XCHAR (c), i + 33, CHARSET_TO_BYTE1_TABLE(cs));
-			  put_byte_from_character_table
-			    (XCHAR (c), j + 33, CHARSET_TO_BYTE2_TABLE(cs));
-			}
-		    }
+		  Lisp_Object c = XVECTOR_DATA(v)[j];
+
+		  if (CHARP (c))
+		    put_char_code_table
+		      (XCHAR (c),
+		       make_int (( (i + CHARSET_BYTE_OFFSET (cs)) << 8)
+				 | (j + CHARSET_BYTE_OFFSET (cs))),
+		       CHARSET_ENCODING_TABLE(cs));
 		}
-	      else if (CHARP (v))
-		put_byte_from_character_table
-		  (XCHAR (v), i + 33, CHARSET_TO_BYTE1_TABLE(cs));
 	    }
+	  else if (CHARP (v))
+	    put_char_code_table (XCHAR (v),
+				 make_int (i + CHARSET_BYTE_OFFSET (cs)),
+				 CHARSET_ENCODING_TABLE(cs));
 	}
-      else
-	{
-	  CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-	  CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-	}
-      break;
-    case CHARSET_TYPE_96X96:
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-      break;
-    case CHARSET_TYPE_128X128:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 128;
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
-      break;
-    case CHARSET_TYPE_256X256:
-      CHARSET_DIMENSION (cs) = 2;
-      CHARSET_CHARS (cs) = 256;
-      CHARSET_TO_BYTE1_TABLE(cs) = NULL;
-      CHARSET_TO_BYTE2_TABLE(cs) = NULL;
       break;
     }
-  if (old_byte1_table != NULL)
-    destroy_byte_from_character_table (old_byte1_table);
-  if (old_byte2_table != NULL)
-    destroy_byte_from_character_table (old_byte2_table);
   return table;
 }
 #endif
@@ -1919,6 +2023,7 @@ syms_of_mule_charset (void)
   defsymbol (&Qchinese_cns11643_2,	"chinese-cns11643-2");
 #ifdef UTF2000
   defsymbol (&Qucs_bmp,			"ucs-bmp");
+  defsymbol (&Qlatin_viscii,		"latin-viscii");
   defsymbol (&Qlatin_viscii_lower,	"latin-viscii-lower");
   defsymbol (&Qlatin_viscii_upper,	"latin-viscii-upper");
   defsymbol (&Qvietnamese_viscii_lower,	"vietnamese-viscii-lower");
@@ -1957,10 +2062,10 @@ vars_of_mule_charset (void)
 	charset_by_attributes[i][j][k] = Qnil;
 #endif
 
-  next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
 #ifdef UTF2000
-  next_allocated_2_byte_leading_byte = LEADING_BYTE_CHINESE_BIG5_2 + 1;
+  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;
 #endif
 
@@ -1973,7 +2078,7 @@ Leading-code of private TYPE9N charset of column-width 1.
 #endif
 
 #ifdef UTF2000
-  Vutf_2000_version = build_string("0.8 (Kami)");
+  Vutf_2000_version = build_string("0.9 (Kyūhōji)");
   DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
 Version number of UTF-2000.
 */ );
@@ -1981,7 +2086,7 @@ Version number of UTF-2000.
   Vdefault_coded_charset_priority_list = Qnil;
   DEFVAR_LISP ("default-coded-charset-priority-list",
 	       &Vdefault_coded_charset_priority_list /*
-Default order of preferred coded-character-set.
+Default order of preferred coded-character-sets.
 */ );
 #endif
 }
@@ -1999,12 +2104,12 @@ complex_vars_of_mule_charset (void)
 #ifdef UTF2000
   Vcharset_ucs_bmp =
     make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp,
-		  CHARSET_TYPE_256X256, 1, 0, 0,
+		  CHARSET_TYPE_256X256, 1, 2, 0,
 		  CHARSET_LEFT_TO_RIGHT,
 		  build_string ("BMP"),
 		  build_string ("BMP"),
-		  build_string ("BMP"),
-		  build_string (""),
+		  build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
+		  build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
 		  Qnil, 0, 0xFFFF, 0, 0);
 #else
 # define MIN_CHAR_THAI 0
@@ -2222,7 +2327,7 @@ complex_vars_of_mule_charset (void)
 		  build_string ("VISCII lower"),
 		  build_string ("VISCII lower (Vietnamese)"),
 		  build_string ("VISCII lower (Vietnamese)"),
-		  build_string ("VISCII1\\.1"),
+		  build_string ("MULEVISCII-LOWER"),
 		  Qnil, 0, 0, 0, 32);
   Vcharset_latin_viscii_upper =
     make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper,
@@ -2231,18 +2336,17 @@ complex_vars_of_mule_charset (void)
 		  build_string ("VISCII upper"),
 		  build_string ("VISCII upper (Vietnamese)"),
 		  build_string ("VISCII upper (Vietnamese)"),
-		  build_string ("VISCII1\\.1"),
+		  build_string ("MULEVISCII-UPPER"),
 		  Qnil, 0, 0, 0, 32);
-  /*
-  Fputhash (Qvietnamese_viscii_lower, Vcharset_latin_viscii_lower,
-	    Vcharset_hash_table);
-  Fputhash (Qvietnamese_viscii_upper, Vcharset_latin_viscii_upper,
-	    Vcharset_hash_table);
-  */
-  Fdefine_charset_alias (Qvietnamese_viscii_lower,
-			 Vcharset_latin_viscii_lower);
-  Fdefine_charset_alias (Qvietnamese_viscii_upper,
-			 Vcharset_latin_viscii_upper);
+  Vcharset_latin_viscii =
+    make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii,
+		  CHARSET_TYPE_256, 1, 2, 0,
+		  CHARSET_LEFT_TO_RIGHT,
+		  build_string ("VISCII"),
+		  build_string ("VISCII 1.1 (Vietnamese)"),
+		  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',