(J90-4A5E): Unify JIS X 0208:1978 and 1983 code points.

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

diff --git a/src/mule-charset.c b/src/mule-charset.c
index bf0f718..3fb4030 100644 (file)
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -1,6 +1,7 @@
 /* Functions to handle multilingual characters.
    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.
 /* Functions to handle multilingual characters.
    Copyright (C) 1992, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.

+   Copyright (C) 1999,2000,2001 MORIOKA Tomohiko

 
 This file is part of XEmacs.
 
 
 This file is part of XEmacs.
 

@@ -19,11 +20,14 @@ along with XEmacs; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 

-/* Synched up with: FSF 20.3.  Not in FSF. */
-

 /* Rewritten by Ben Wing <ben@xemacs.org>. */
 
 /* Rewritten by Ben Wing <ben@xemacs.org>. */
 

+/* Rewritten by MORIOKA Tomohiko <tomo@m17n.org> for XEmacs UTF-2000. */
+

 #include <config.h>
 #include <config.h>

+#ifdef UTF2000
+#include <limits.h>
+#endif

 #include "lisp.h"
 
 #include "buffer.h"
 #include "lisp.h"
 
 #include "buffer.h"

@@ -52,11 +56,64 @@ Lisp_Object Vcharset_cyrillic_iso8859_5;
 Lisp_Object Vcharset_latin_iso8859_9;
 Lisp_Object Vcharset_japanese_jisx0208_1978;
 Lisp_Object Vcharset_chinese_gb2312;
 Lisp_Object Vcharset_latin_iso8859_9;
 Lisp_Object Vcharset_japanese_jisx0208_1978;
 Lisp_Object Vcharset_chinese_gb2312;

+Lisp_Object Vcharset_chinese_gb12345;

 Lisp_Object Vcharset_japanese_jisx0208;
 Lisp_Object Vcharset_japanese_jisx0208;

+Lisp_Object Vcharset_japanese_jisx0208_1990;

 Lisp_Object Vcharset_korean_ksc5601;
 Lisp_Object Vcharset_japanese_jisx0212;
 Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;
 Lisp_Object Vcharset_korean_ksc5601;
 Lisp_Object Vcharset_japanese_jisx0212;
 Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;

+#ifdef UTF2000
+Lisp_Object Vcharset_ucs;
+Lisp_Object Vcharset_ucs_bmp;
+Lisp_Object Vcharset_ucs_cns;
+Lisp_Object Vcharset_ucs_jis;
+Lisp_Object Vcharset_ucs_big5;
+Lisp_Object Vcharset_latin_viscii;
+Lisp_Object Vcharset_latin_tcvn5712;
+Lisp_Object Vcharset_latin_viscii_lower;
+Lisp_Object Vcharset_latin_viscii_upper;
+Lisp_Object Vcharset_chinese_big5;
+Lisp_Object Vcharset_chinese_big5_cdp;
+Lisp_Object Vcharset_japanese_jef_china3;
+Lisp_Object Vcharset_ideograph_gt;
+Lisp_Object Vcharset_ideograph_gt_pj_1;
+Lisp_Object Vcharset_ideograph_gt_pj_2;
+Lisp_Object Vcharset_ideograph_gt_pj_3;
+Lisp_Object Vcharset_ideograph_gt_pj_4;
+Lisp_Object Vcharset_ideograph_gt_pj_5;
+Lisp_Object Vcharset_ideograph_gt_pj_6;
+Lisp_Object Vcharset_ideograph_gt_pj_7;
+Lisp_Object Vcharset_ideograph_gt_pj_8;
+Lisp_Object Vcharset_ideograph_gt_pj_9;
+Lisp_Object Vcharset_ideograph_gt_pj_10;
+Lisp_Object Vcharset_ideograph_gt_pj_11;
+Lisp_Object Vcharset_ideograph_daikanwa;
+Lisp_Object Vcharset_mojikyo;
+Lisp_Object Vcharset_mojikyo_2022_1;
+Lisp_Object Vcharset_mojikyo_pj_1;
+Lisp_Object Vcharset_mojikyo_pj_2;
+Lisp_Object Vcharset_mojikyo_pj_3;
+Lisp_Object Vcharset_mojikyo_pj_4;
+Lisp_Object Vcharset_mojikyo_pj_5;
+Lisp_Object Vcharset_mojikyo_pj_6;
+Lisp_Object Vcharset_mojikyo_pj_7;
+Lisp_Object Vcharset_mojikyo_pj_8;
+Lisp_Object Vcharset_mojikyo_pj_9;
+Lisp_Object Vcharset_mojikyo_pj_10;
+Lisp_Object Vcharset_mojikyo_pj_11;
+Lisp_Object Vcharset_mojikyo_pj_12;
+Lisp_Object Vcharset_mojikyo_pj_13;
+Lisp_Object Vcharset_mojikyo_pj_14;
+Lisp_Object Vcharset_mojikyo_pj_15;
+Lisp_Object Vcharset_mojikyo_pj_16;
+Lisp_Object Vcharset_mojikyo_pj_17;
+Lisp_Object Vcharset_mojikyo_pj_18;
+Lisp_Object Vcharset_mojikyo_pj_19;
+Lisp_Object Vcharset_mojikyo_pj_20;
+Lisp_Object Vcharset_mojikyo_pj_21;
+Lisp_Object Vcharset_ethiopic_ucs;
+#endif

 Lisp_Object Vcharset_chinese_big5_1;
 Lisp_Object Vcharset_chinese_big5_2;
 
 Lisp_Object Vcharset_chinese_big5_1;
 Lisp_Object Vcharset_chinese_big5_2;
 

@@ -77,8 +134,13 @@ static int composite_char_col_next;
 struct charset_lookup *chlook;
 
 static const struct lrecord_description charset_lookup_description_1[] = {
 struct charset_lookup *chlook;
 
 static const struct lrecord_description charset_lookup_description_1[] = {

-  { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), 128+4*128*2 },
-  { XD_END }
+  { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte),
+#ifdef UTF2000
+    128+4*128
+#else
+    128+4*128*2 
+#endif
+  }, { XD_END }

 };
 
 static const struct struct_description charset_lookup_description = {
 };
 
 static const struct struct_description charset_lookup_description = {

@@ -86,6 +148,7 @@ static const struct struct_description charset_lookup_description = {
   charset_lookup_description_1
 };
 
   charset_lookup_description_1
 };
 

+#ifndef UTF2000

 /* Table of number of bytes in the string representation of a character
    indexed by the first byte of that representation.
 
 /* Table of number of bytes in the string representation of a character
    indexed by the first byte of that representation.
 

@@ -105,12 +168,226 @@ const Bytecount rep_bytes_by_first_byte[0xA0] =
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   /* 0x80 - 0x8f are for Dimension-1 official charsets */
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   /* 0x80 - 0x8f are for Dimension-1 official charsets */

+#ifdef CHAR_IS_UCS4
+  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
+#else

   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

+#endif

   /* 0x90 - 0x9d are for Dimension-2 official charsets */
   /* 0x9e is for Dimension-1 private charsets */
   /* 0x9f is for Dimension-2 private charsets */
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
 };
   /* 0x90 - 0x9d are for Dimension-2 official charsets */
   /* 0x9e is for Dimension-1 private charsets */
   /* 0x9f is for Dimension-2 private charsets */
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4
 };

+#endif
+
+#ifdef UTF2000
+
+INLINE_HEADER int CHARSET_BYTE_SIZE (Lisp_Charset* cs);
+INLINE_HEADER int
+CHARSET_BYTE_SIZE (Lisp_Charset* cs)
+{
+  /* ad-hoc method for `ascii' */
+  if ((CHARSET_CHARS (cs) == 94) &&
+      (CHARSET_BYTE_OFFSET (cs) != 33))
+    return 128 - CHARSET_BYTE_OFFSET (cs);
+  else
+    return CHARSET_CHARS (cs);
+}
+
+#define XCHARSET_BYTE_SIZE(ccs)        CHARSET_BYTE_SIZE (XCHARSET (ccs))
+
+int decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len);
+int
+decoding_table_check_elements (Lisp_Object v, int dim, int ccs_len)
+{
+  int 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;
+
+      dim--;
+      i = ((code_point >> (8 * dim)) & 255) - byte_offset;
+      nv = XVECTOR_DATA(v)[i];
+      if (!VECTORP (nv))
+       break;
+      v = nv;
+    }
+  if (i >= 0)
+    XVECTOR_DATA(v)[i] = Qnil;
+}
+
+INLINE_HEADER void
+decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
+                        int code_point, Lisp_Object character);
+INLINE_HEADER void
+decoding_table_put_char (Lisp_Object v, int dim, int byte_offset,
+                        int code_point, Lisp_Object character)
+{
+  int i = -1;
+  Lisp_Object nv;
+  int ccs_len = XVECTOR_LENGTH (v);
+
+  while (dim > 0)
+    {
+      dim--;
+      i = ((code_point >> (8 * dim)) & 255) - byte_offset;
+      nv = XVECTOR_DATA(v)[i];
+      if (dim > 0)
+       {
+         if (!VECTORP (nv))
+           nv = (XVECTOR_DATA(v)[i] = make_older_vector (ccs_len, Qnil));
+         v = nv;
+       }
+      else
+       break;
+    }
+  XVECTOR_DATA(v)[i] = character;
+}
+
+Lisp_Object
+put_char_ccs_code_point (Lisp_Object character,
+                        Lisp_Object ccs, Lisp_Object value)
+{
+  Lisp_Object encoding_table;
+
+  if (!EQ (XCHARSET_NAME (ccs), Qucs)
+      || (XCHAR (character) != XINT (value)))
+    {
+      Lisp_Object v = XCHARSET_DECODING_TABLE (ccs);
+      int dim = XCHARSET_DIMENSION (ccs);
+      int ccs_len = XCHARSET_BYTE_SIZE (ccs);
+      int byte_offset = XCHARSET_BYTE_OFFSET (ccs);
+      int code_point;
+
+      if (CONSP (value))
+       { /* obsolete representation: value must be a list of bytes */
+         Lisp_Object ret = Fcar (value);
+         Lisp_Object rest;
+
+         if (!INTP (ret))
+           signal_simple_error ("Invalid value for coded-charset", value);
+         code_point = XINT (ret);
+         if (XCHARSET_GRAPHIC (ccs) == 1)
+           code_point &= 0x7F;
+         rest = Fcdr (value);
+         while (!NILP (rest))
+           {
+             int j;
+
+             if (!CONSP (rest))
+               signal_simple_error ("Invalid value for coded-charset",
+                                    value);
+             ret = Fcar (rest);
+             if (!INTP (ret))
+               signal_simple_error ("Invalid value for coded-charset",
+                                    value);
+             j = XINT (ret);
+             if (XCHARSET_GRAPHIC (ccs) == 1)
+               j &= 0x7F;
+             code_point = (code_point << 8) | j;
+             rest = Fcdr (rest);
+           }
+         value = make_int (code_point);
+       }
+      else if (INTP (value))
+       {
+         code_point = XINT (value);
+         if (XCHARSET_GRAPHIC (ccs) == 1)
+           {
+             code_point &= 0x7F7F7F7F;
+             value = make_int (code_point);
+           }
+       }
+      else
+       signal_simple_error ("Invalid value for coded-charset", value);
+
+      if (VECTORP (v))
+       {
+         Lisp_Object cpos = Fget_char_attribute (character, ccs, Qnil);
+         if (!NILP (cpos))
+           {
+             decoding_table_remove_char (v, dim, byte_offset, XINT (cpos));
+           }
+       }
+      else
+       {
+         XCHARSET_DECODING_TABLE (ccs)
+           = v = make_older_vector (ccs_len, Qnil);
+       }
+
+      decoding_table_put_char (v, dim, byte_offset, code_point, character);
+    }
+  if (NILP (encoding_table = XCHARSET_ENCODING_TABLE (ccs)))
+    {
+      XCHARSET_ENCODING_TABLE (ccs)
+       = encoding_table = make_char_id_table (Qnil);
+    }
+  put_char_id_table (XCHAR_TABLE(encoding_table), character, value);
+  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, Qnil);
+
+      if (!NILP (cpos))
+       {
+         decoding_table_remove_char (decoding_table,
+                                     XCHARSET_DIMENSION (ccs),
+                                     XCHARSET_BYTE_OFFSET (ccs),
+                                     XINT (cpos));
+       }
+    }
+  if (CHAR_TABLEP (encoding_table))
+    {
+      put_char_id_table (XCHAR_TABLE(encoding_table), character, Qnil);
+    }
+  return Qt;
+}
+
+#endif
+
+#ifndef UTF2000
+int leading_code_private_11;
+#endif

 
 Lisp_Object Qcharsetp;
 
 
 Lisp_Object Qcharsetp;
 

@@ -137,11 +414,66 @@ Lisp_Object Qascii,
   Qlatin_iso8859_9,
   Qjapanese_jisx0208_1978,
   Qchinese_gb2312,
   Qlatin_iso8859_9,
   Qjapanese_jisx0208_1978,
   Qchinese_gb2312,

+  Qchinese_gb12345,

   Qjapanese_jisx0208,
   Qjapanese_jisx0208,

+  Qjapanese_jisx0208_1990,

   Qkorean_ksc5601,
   Qjapanese_jisx0212,
   Qchinese_cns11643_1,
   Qchinese_cns11643_2,
   Qkorean_ksc5601,
   Qjapanese_jisx0212,
   Qchinese_cns11643_1,
   Qchinese_cns11643_2,

+#ifdef UTF2000
+  Qucs,
+  Qucs_bmp,
+  Qucs_cns,
+  Qucs_jis,
+  Qucs_big5,
+  Qlatin_viscii,
+  Qlatin_tcvn5712,
+  Qlatin_viscii_lower,
+  Qlatin_viscii_upper,
+  Qvietnamese_viscii_lower,
+  Qvietnamese_viscii_upper,
+  Qchinese_big5,
+  Qchinese_big5_cdp,
+  Qjapanese_jef_china3,
+  Qideograph_daikanwa,
+  Qideograph_gt,
+  Qideograph_gt_pj_1,
+  Qideograph_gt_pj_2,
+  Qideograph_gt_pj_3,
+  Qideograph_gt_pj_4,
+  Qideograph_gt_pj_5,
+  Qideograph_gt_pj_6,
+  Qideograph_gt_pj_7,
+  Qideograph_gt_pj_8,
+  Qideograph_gt_pj_9,
+  Qideograph_gt_pj_10,
+  Qideograph_gt_pj_11,
+  Qmojikyo,
+  Qmojikyo_2022_1,
+  Qmojikyo_pj_1,
+  Qmojikyo_pj_2,
+  Qmojikyo_pj_3,
+  Qmojikyo_pj_4,
+  Qmojikyo_pj_5,
+  Qmojikyo_pj_6,
+  Qmojikyo_pj_7,
+  Qmojikyo_pj_8,
+  Qmojikyo_pj_9,
+  Qmojikyo_pj_10,
+  Qmojikyo_pj_11,
+  Qmojikyo_pj_12,
+  Qmojikyo_pj_13,
+  Qmojikyo_pj_14,
+  Qmojikyo_pj_15,
+  Qmojikyo_pj_16,
+  Qmojikyo_pj_17,
+  Qmojikyo_pj_18,
+  Qmojikyo_pj_19,
+  Qmojikyo_pj_20,
+  Qmojikyo_pj_21,
+  Qethiopic_ucs,
+#endif

   Qchinese_big5_1,
   Qchinese_big5_2,
   Qcomposite;
   Qchinese_big5_1,
   Qchinese_big5_2,
   Qcomposite;

@@ -150,9 +482,6 @@ Lisp_Object Ql2r, Qr2l;
 
 Lisp_Object Vcharset_hash_table;
 
 
 Lisp_Object Vcharset_hash_table;
 

-static Bufbyte next_allocated_1_byte_leading_byte;
-static Bufbyte next_allocated_2_byte_leading_byte;
-

 /* Composite characters are characters constructed by overstriking two
    or more regular characters.
 
 /* Composite characters are characters constructed by overstriking two
    or more regular characters.
 

@@ -196,11 +525,54 @@ Bytecount
 non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
 {
   Bufbyte *p;
 non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
 {
   Bufbyte *p;

-  Bufbyte lb;
+#ifndef UTF2000
+  Charset_ID lb;

   int c1, c2;
   Lisp_Object charset;
   int c1, c2;
   Lisp_Object charset;

+#endif

 
   p = str;
 
   p = str;

+#ifdef UTF2000
+  if ( c <= 0x7f )
+    {
+      *p++ = c;
+    }
+  else if ( c <= 0x7ff )
+    {
+      *p++ = (c >> 6) | 0xc0;
+      *p++ = (c & 0x3f) | 0x80;
+    }
+  else if ( c <= 0xffff )
+    {
+      *p++ =  (c >> 12) | 0xe0;
+      *p++ = ((c >>  6) & 0x3f) | 0x80;
+      *p++ =  (c        & 0x3f) | 0x80;
+    }
+  else if ( c <= 0x1fffff )
+    {
+      *p++ =  (c >> 18) | 0xf0;
+      *p++ = ((c >> 12) & 0x3f) | 0x80;
+      *p++ = ((c >>  6) & 0x3f) | 0x80;
+      *p++ =  (c        & 0x3f) | 0x80;
+    }
+  else if ( c <= 0x3ffffff )
+    {
+      *p++ =  (c >> 24) | 0xf8;
+      *p++ = ((c >> 18) & 0x3f) | 0x80;
+      *p++ = ((c >> 12) & 0x3f) | 0x80;
+      *p++ = ((c >>  6) & 0x3f) | 0x80;
+      *p++ =  (c        & 0x3f) | 0x80;
+    }
+  else
+    {
+      *p++ =  (c >> 30) | 0xfc;
+      *p++ = ((c >> 24) & 0x3f) | 0x80;
+      *p++ = ((c >> 18) & 0x3f) | 0x80;
+      *p++ = ((c >> 12) & 0x3f) | 0x80;
+      *p++ = ((c >>  6) & 0x3f) | 0x80;
+      *p++ =  (c        & 0x3f) | 0x80;
+    }
+#else

   BREAKUP_CHAR (c, charset, c1, c2);
   lb = CHAR_LEADING_BYTE (c);
   if (LEADING_BYTE_PRIVATE_P (lb))
   BREAKUP_CHAR (c, charset, c1, c2);
   lb = CHAR_LEADING_BYTE (c);
   if (LEADING_BYTE_PRIVATE_P (lb))

@@ -211,7 +583,7 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
   *p++ = c1 | 0x80;
   if (c2)
     *p++ = c2 | 0x80;
   *p++ = c1 | 0x80;
   if (c2)
     *p++ = c2 | 0x80;

-
+#endif

   return (p - str);
 }
 
   return (p - str);
 }
 

@@ -222,6 +594,49 @@ non_ascii_set_charptr_emchar (Bufbyte *str, Emchar c)
 Emchar
 non_ascii_charptr_emchar (const Bufbyte *str)
 {
 Emchar
 non_ascii_charptr_emchar (const Bufbyte *str)
 {

+#ifdef UTF2000
+  Bufbyte b;
+  Emchar ch;
+  int len;
+
+  b = *str++;
+  if ( b >= 0xfc )
+    {
+      ch = (b & 0x01);
+      len = 5;
+    }
+  else if ( b >= 0xf8 )
+    {
+      ch = b & 0x03;
+      len = 4;
+    }
+  else if ( b >= 0xf0 )
+    {
+      ch = b & 0x07;
+      len = 3;
+    }
+  else if ( b >= 0xe0 )
+    {
+      ch = b & 0x0f;
+      len = 2;
+    }
+  else if ( b >= 0xc0 )
+    {
+      ch = b & 0x1f;
+      len = 1;
+    }
+  else
+    {
+      ch = b;
+      len = 0;
+    }
+  for( ; len > 0; len-- )
+    {
+      b = *str++;
+      ch = ( ch << 6 ) | ( b & 0x3f );
+    }
+  return ch;
+#else

   Bufbyte i0 = *str, i1, i2 = 0;
   Lisp_Object charset;
 
   Bufbyte i0 = *str, i1, i2 = 0;
   Lisp_Object charset;
 

@@ -238,11 +653,13 @@ non_ascii_charptr_emchar (const Bufbyte *str)
     i2 = *++str & 0x7F;
 
   return MAKE_CHAR (charset, i1, i2);
     i2 = *++str & 0x7F;
 
   return MAKE_CHAR (charset, i1, i2);

+#endif

 }
 
 /* Return whether CH is a valid Emchar, assuming it's non-ASCII.
    Do not call this directly.  Use the macro valid_char_p() instead. */
 
 }
 
 /* Return whether CH is a valid Emchar, assuming it's non-ASCII.
    Do not call this directly.  Use the macro valid_char_p() instead. */
 

+#ifndef UTF2000

 int
 non_ascii_valid_char_p (Emchar ch)
 {
 int
 non_ascii_valid_char_p (Emchar ch)
 {

@@ -319,32 +736,25 @@ non_ascii_valid_char_p (Emchar ch)
       return (XCHARSET_CHARS (charset) == 96);
     }
 }
       return (XCHARSET_CHARS (charset) == 96);
     }
 }

+#endif

 
 \f
 /************************************************************************/
 /*                       Basic string functions                         */
 /************************************************************************/
 
 
 \f
 /************************************************************************/
 /*                       Basic string functions                         */
 /************************************************************************/
 

-/* Copy the character pointed to by PTR into STR, assuming it's
-   non-ASCII.  Do not call this directly.  Use the macro
-   charptr_copy_char() instead. */
+/* Copy the character pointed to by SRC into DST.  Do not call this
+   directly.  Use the macro charptr_copy_char() instead.
+   Return the number of bytes copied.  */

 
 Bytecount
 
 Bytecount

-non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
+non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst)

 {
 {

-  Bufbyte *strptr = str;
-  *strptr = *ptr++;
-  switch (REP_BYTES_BY_FIRST_BYTE (*strptr))
-    {
-      /* Notice fallthrough. */
-    case 4: *++strptr = *ptr++;
-    case 3: *++strptr = *ptr++;
-    case 2: *++strptr = *ptr;
-      break;
-    default:
-      abort ();
-    }
-  return strptr + 1 - str;
+  unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src);
+  unsigned int i;
+  for (i = bytes; i; i--, dst++, src++)
+    *dst = *src;
+  return bytes;

 }
 
 \f
 }
 
 \f

@@ -361,26 +771,15 @@ Lstream_get_emchar_1 (Lstream *stream, int ch)
 {
   Bufbyte str[MAX_EMCHAR_LEN];
   Bufbyte *strptr = str;
 {
   Bufbyte str[MAX_EMCHAR_LEN];
   Bufbyte *strptr = str;

+  unsigned int bytes;

 
   str[0] = (Bufbyte) ch;
 
   str[0] = (Bufbyte) ch;

-  switch (REP_BYTES_BY_FIRST_BYTE (ch))
-    {
-      /* Notice fallthrough. */
-    case 4:
-      ch = Lstream_getc (stream);
-      assert (ch >= 0);
-      *++strptr = (Bufbyte) ch;
-    case 3:
-      ch = Lstream_getc (stream);
-      assert (ch >= 0);
-      *++strptr = (Bufbyte) ch;
-    case 2:
-      ch = Lstream_getc (stream);
-      assert (ch >= 0);
-      *++strptr = (Bufbyte) ch;
-      break;
-    default:
-      abort ();
+
+  for (bytes = REP_BYTES_BY_FIRST_BYTE (ch) - 1; bytes; bytes--)
+    {
+      int c = Lstream_getc (stream);
+      bufpos_checking_assert (c >= 0);
+      *++strptr = (Bufbyte) c;

     }
   return charptr_emchar (str);
 }
     }
   return charptr_emchar (str);
 }

@@ -416,6 +815,10 @@ mark_charset (Lisp_Object obj)
   mark_object (cs->doc_string);
   mark_object (cs->registry);
   mark_object (cs->ccl_program);
   mark_object (cs->doc_string);
   mark_object (cs->registry);
   mark_object (cs->ccl_program);

+#ifdef UTF2000
+  mark_object (cs->encoding_table);
+  /* mark_object (cs->decoding_table); */
+#endif

   return cs->name;
 }
 
   return cs->name;
 }
 

@@ -438,11 +841,9 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
   print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
   write_c_string (" ", printcharfun);
   print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);
   print_internal (CHARSET_LONG_NAME (cs), printcharfun, 1);
   write_c_string (" ", printcharfun);
   print_internal (CHARSET_DOC_STRING (cs), printcharfun, 1);

-  sprintf (buf, " %s %s cols=%d g%d final='%c' reg=",
-          CHARSET_TYPE (cs) == CHARSET_TYPE_94    ? "94" :
-          CHARSET_TYPE (cs) == CHARSET_TYPE_96    ? "96" :
-          CHARSET_TYPE (cs) == CHARSET_TYPE_94X94 ? "94x94" :
-          "96x96",
+  sprintf (buf, " %d^%d %s cols=%d g%d final='%c' reg=",
+          CHARSET_CHARS (cs),
+          CHARSET_DIMENSION (cs),

           CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l",
           CHARSET_COLUMNS (cs),
           CHARSET_GRAPHIC (cs),
           CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : "r2l",
           CHARSET_COLUMNS (cs),
           CHARSET_GRAPHIC (cs),

@@ -461,20 +862,30 @@ static const struct lrecord_description charset_description[] = {
   { 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) },
   { 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 (Lisp_Charset, decoding_table) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, encoding_table) },
+#endif

   { XD_END }
 };
 
 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
   { XD_END }
 };
 
 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,

-                               mark_charset, print_charset, 0, 0, 0, charset_description,
+                               mark_charset, print_charset, 0, 0, 0,
+                              charset_description,

                               Lisp_Charset);
                               Lisp_Charset);

-/* Make a new charset. */

 
 

+/* Make a new charset. */
+/* #### SJT Should generic properties be allowed? */

 static Lisp_Object
 static Lisp_Object

-make_charset (int id, Lisp_Object name, unsigned char rep_bytes,
-             unsigned char type, unsigned char columns, unsigned char graphic,
-             Bufbyte final, unsigned char direction,  Lisp_Object short_name,
+make_charset (Charset_ID id, Lisp_Object name,
+             unsigned short chars, unsigned char dimension,
+             unsigned char columns, unsigned char graphic,
+             Bufbyte final, unsigned char direction, Lisp_Object short_name,

              Lisp_Object long_name, Lisp_Object doc,
              Lisp_Object long_name, Lisp_Object doc,

-             Lisp_Object reg)
+             Lisp_Object reg,
+             Lisp_Object decoding_table,
+             Emchar ucs_min, Emchar ucs_max,
+             Emchar code_offset, unsigned char byte_offset)

 {
   Lisp_Object obj;
   Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
 {
   Lisp_Object obj;
   Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);

@@ -487,9 +898,9 @@ make_charset (int id, Lisp_Object name, unsigned char rep_bytes,
   CHARSET_NAME         (cs) = name;
   CHARSET_SHORT_NAME   (cs) = short_name;
   CHARSET_LONG_NAME    (cs) = long_name;
   CHARSET_NAME         (cs) = name;
   CHARSET_SHORT_NAME   (cs) = short_name;
   CHARSET_LONG_NAME    (cs) = long_name;

-  CHARSET_REP_BYTES    (cs) = rep_bytes;
+  CHARSET_CHARS                (cs) = chars;
+  CHARSET_DIMENSION    (cs) = dimension;

   CHARSET_DIRECTION    (cs) = direction;
   CHARSET_DIRECTION    (cs) = direction;

-  CHARSET_TYPE         (cs) = type;

   CHARSET_COLUMNS      (cs) = columns;
   CHARSET_GRAPHIC      (cs) = graphic;
   CHARSET_FINAL                (cs) = final;
   CHARSET_COLUMNS      (cs) = columns;
   CHARSET_GRAPHIC      (cs) = graphic;
   CHARSET_FINAL                (cs) = final;

@@ -497,23 +908,46 @@ make_charset (int id, Lisp_Object name, unsigned char rep_bytes,
   CHARSET_REGISTRY     (cs) = reg;
   CHARSET_CCL_PROGRAM  (cs) = Qnil;
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;
   CHARSET_REGISTRY     (cs) = reg;
   CHARSET_CCL_PROGRAM  (cs) = Qnil;
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil;

+#ifdef UTF2000
+  CHARSET_DECODING_TABLE(cs) = Qnil;
+  CHARSET_ENCODING_TABLE(cs) = Qnil;
+  CHARSET_UCS_MIN(cs) = ucs_min;
+  CHARSET_UCS_MAX(cs) = ucs_max;
+  CHARSET_CODE_OFFSET(cs) = code_offset;
+  CHARSET_BYTE_OFFSET(cs) = byte_offset;
+#endif

 
 

-  CHARSET_DIMENSION     (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 ||
-                               CHARSET_TYPE (cs) == CHARSET_TYPE_96) ? 1 : 2;
-  CHARSET_CHARS         (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 ||
-                               CHARSET_TYPE (cs) == CHARSET_TYPE_94X94) ? 94 : 96;
+#ifndef UTF2000
+  if (id == LEADING_BYTE_ASCII)
+    CHARSET_REP_BYTES (cs) = 1;
+  else if (id < 0xA0)
+    CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 1;
+  else
+    CHARSET_REP_BYTES (cs) = CHARSET_DIMENSION (cs) + 2;
+#endif

 
   if (final)
     {
       /* some charsets do not have final characters.  This includes
         ASCII, Control-1, Composite, and the two faux private
         charsets. */
 
   if (final)
     {
       /* some charsets do not have final characters.  This includes
         ASCII, Control-1, Composite, and the two faux private
         charsets. */

-      assert (NILP (chlook->charset_by_attributes[type][final][direction]));
-      chlook->charset_by_attributes[type][final][direction] = obj;
+      unsigned char iso2022_type
+       = (dimension == 1 ? 0 : 2) + (chars == 94 ? 0 : 1);
+#if UTF2000
+      if (code_offset == 0)
+       {
+         assert (NILP (chlook->charset_by_attributes[iso2022_type][final]));
+         chlook->charset_by_attributes[iso2022_type][final] = obj;
+       }
+#else
+      assert (NILP
+             (chlook->charset_by_attributes[iso2022_type][final][direction]));
+      chlook->charset_by_attributes[iso2022_type][final][direction] = obj;
+#endif

     }
 
     }
 

-  assert (NILP (chlook->charset_by_leading_byte[id - 128]));
-  chlook->charset_by_leading_byte[id - 128] = obj;
+  assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE]));
+  chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj;

 
   /* Some charsets are "faux" and don't have names or really exist at
      all except in the leading-byte table. */
 
   /* Some charsets are "faux" and don't have names or really exist at
      all except in the leading-byte table. */

@@ -525,22 +959,29 @@ make_charset (int id, Lisp_Object name, unsigned char rep_bytes,
 static int
 get_unallocated_leading_byte (int dimension)
 {
 static int
 get_unallocated_leading_byte (int dimension)
 {

-  int lb;
+  Charset_ID lb;

 
 

+#ifdef UTF2000
+  if (chlook->next_allocated_leading_byte > MAX_LEADING_BYTE_PRIVATE)
+    lb = 0;
+  else
+    lb = chlook->next_allocated_leading_byte++;
+#else

   if (dimension == 1)
     {
   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 = 0;
       else

-       lb = next_allocated_1_byte_leading_byte++;
+       lb = chlook->next_allocated_1_byte_leading_byte++;

     }
   else
     {
     }
   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 = 0;
       else

-       lb = next_allocated_2_byte_leading_byte++;
+       lb = chlook->next_allocated_2_byte_leading_byte++;

     }
     }

+#endif

 
   if (!lb)
     signal_simple_error
 
   if (!lb)
     signal_simple_error

@@ -550,6 +991,347 @@ get_unallocated_leading_byte (int dimension)
   return lb;
 }
 
   return lb;
 }
 

+#ifdef UTF2000
+/* Number of Big5 characters which have the same code in 1st byte.  */
+
+#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
+
+Emchar
+decode_builtin_char (Lisp_Object charset, int code_point)
+{
+  int final;
+
+  if (EQ (charset, Vcharset_chinese_big5))
+    {
+      int c1 = code_point >> 8;
+      int c2 = code_point & 0xFF;
+      unsigned int I;
+
+      if ( (  (0xA1 <= c1) && (c1 <= 0xFE)  )
+          &&
+          ( ((0x40 <= c2) && (c2 <= 0x7E)) ||
+            ((0xA1 <= c2) && (c2 <= 0xFE)) ) )
+       {
+         I = (c1 - 0xA1) * BIG5_SAME_ROW
+           + c2 - (c2 < 0x7F ? 0x40 : 0x62);
+
+         if (c1 < 0xC9)
+           {
+             charset = Vcharset_chinese_big5_1;
+           }
+         else
+           {
+             charset = Vcharset_chinese_big5_2;
+             I -= (BIG5_SAME_ROW) * (0xC9 - 0xA1);
+           }
+         code_point = ((I / 94 + 33) << 8) | (I % 94 + 33);
+       }
+    }
+  if ((final = XCHARSET_FINAL (charset)) >= '0')
+    {
+      if (XCHARSET_DIMENSION (charset) == 1)
+       {
+         switch (XCHARSET_CHARS (charset))
+           {
+           case 94:
+             return MIN_CHAR_94
+               + (final - '0') * 94 + ((code_point & 0x7F) - 33);
+           case 96:
+             return MIN_CHAR_96
+               + (final - '0') * 96 + ((code_point & 0x7F) - 32);
+           default:
+             abort ();
+             return -1;
+           }
+       }
+      else
+       {
+         switch (XCHARSET_CHARS (charset))
+           {
+           case 94:
+             return MIN_CHAR_94x94
+               + (final - '0') * 94 * 94
+               + (((code_point >> 8) & 0x7F) - 33) * 94
+               + ((code_point & 0x7F) - 33);
+           case 96:
+             return MIN_CHAR_96x96
+               + (final - '0') * 96 * 96
+               + (((code_point >> 8) & 0x7F) - 32) * 96
+               + ((code_point & 0x7F) - 32);
+           default:
+             abort ();
+             return -1;
+           }
+       }
+    }
+  else if (XCHARSET_UCS_MAX (charset))
+    {
+      Emchar cid
+       = (XCHARSET_DIMENSION (charset) == 1
+          ?
+          code_point - XCHARSET_BYTE_OFFSET (charset)
+          :
+          ((code_point >> 8) - XCHARSET_BYTE_OFFSET (charset))
+          * XCHARSET_CHARS (charset)
+          + (code_point & 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 -1;
+      return cid;
+    }
+  else
+    return -1;
+}
+
+int
+range_charset_code_point (Lisp_Object charset, Emchar ch)
+{
+  int d;
+
+  if ((XCHARSET_UCS_MIN (charset) <= ch)
+      && (ch <= XCHARSET_UCS_MAX (charset)))
+    {
+      d = ch - XCHARSET_UCS_MIN (charset) + XCHARSET_CODE_OFFSET (charset);
+
+      if (XCHARSET_CHARS (charset) == 256)
+       return d;
+      else if (XCHARSET_DIMENSION (charset) == 1)
+       return d + XCHARSET_BYTE_OFFSET (charset);
+      else if (XCHARSET_DIMENSION (charset) == 2)
+       return
+         ((d / XCHARSET_CHARS (charset)
+           + XCHARSET_BYTE_OFFSET (charset)) << 8)
+         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
+      else if (XCHARSET_DIMENSION (charset) == 3)
+       return
+         ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
+           + XCHARSET_BYTE_OFFSET (charset)) << 16)
+         | ((d / XCHARSET_CHARS (charset)
+             % XCHARSET_CHARS (charset)
+             + XCHARSET_BYTE_OFFSET (charset)) << 8)
+         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
+      else /* if (XCHARSET_DIMENSION (charset) == 4) */
+       return
+         ((d / (XCHARSET_CHARS (charset)
+                * XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
+           + XCHARSET_BYTE_OFFSET (charset)) << 24)
+         | ((d / (XCHARSET_CHARS (charset) * XCHARSET_CHARS (charset))
+             % XCHARSET_CHARS (charset)
+             + XCHARSET_BYTE_OFFSET (charset)) << 16)
+         | ((d / XCHARSET_CHARS (charset) % XCHARSET_CHARS (charset)
+             + XCHARSET_BYTE_OFFSET (charset)) << 8)
+         | (d % XCHARSET_CHARS (charset) + XCHARSET_BYTE_OFFSET (charset));
+    }
+  else if (XCHARSET_CODE_OFFSET (charset) == 0)
+    {
+      if (XCHARSET_DIMENSION (charset) == 1)
+       {
+         if (XCHARSET_CHARS (charset) == 94)
+           {
+             if (((d = ch - (MIN_CHAR_94
+                             + (XCHARSET_FINAL (charset) - '0') * 94)) >= 0)
+                 && (d < 94))
+               return d + 33;
+           }
+         else if (XCHARSET_CHARS (charset) == 96)
+           {
+             if (((d = ch - (MIN_CHAR_96
+                             + (XCHARSET_FINAL (charset) - '0') * 96)) >= 0)
+                 && (d < 96))
+               return d + 32;
+           }
+         else
+           return -1;
+       }
+      else if (XCHARSET_DIMENSION (charset) == 2)
+       {
+         if (XCHARSET_CHARS (charset) == 94)
+           {
+             if (((d = ch - (MIN_CHAR_94x94
+                             + (XCHARSET_FINAL (charset) - '0') * 94 * 94))
+                  >= 0)
+                 && (d < 94 * 94))
+               return (((d / 94) + 33) << 8) | (d % 94 + 33);
+           }
+         else if (XCHARSET_CHARS (charset) == 96)
+           {
+             if (((d = ch - (MIN_CHAR_96x96
+                             + (XCHARSET_FINAL (charset) - '0') * 96 * 96))
+                  >= 0)
+                 && (d < 96 * 96))
+               return (((d / 96) + 32) << 8) | (d % 96 + 32);
+           }
+         else
+           return -1;
+       }
+    }
+  if (EQ (charset, Vcharset_mojikyo_2022_1)
+      && (MIN_CHAR_MOJIKYO < ch) && (ch < MIN_CHAR_MOJIKYO + 94 * 60 * 94))
+    {
+      int m = ch - MIN_CHAR_MOJIKYO - 1;
+      int byte1 =  m / (94 * 60) + 33;
+      int byte2 = (m % (94 * 60)) / 94;
+      int byte3 =  m % 94 + 33;
+
+      if (byte2 < 30)
+       byte2 += 16 + 32;
+      else
+       byte2 += 18 + 32;
+      return (byte1 << 16) | (byte2 << 8) | byte3;
+    }
+  return -1;
+}
+
+int
+encode_builtin_char_1 (Emchar c, Lisp_Object* charset)
+{
+  if (c <= MAX_CHAR_BASIC_LATIN)
+    {
+      *charset = Vcharset_ascii;
+      return c;
+    }
+  else if (c < 0xA0)
+    {
+      *charset = Vcharset_control_1;
+      return c & 0x7F;
+    }
+  else if (c <= 0xff)
+    {
+      *charset = Vcharset_latin_iso8859_1;
+      return c & 0x7F;
+    }
+  /*
+  else if ((MIN_CHAR_HEBREW <= c) && (c <= MAX_CHAR_HEBREW))
+    {
+      *charset = Vcharset_hebrew_iso8859_8;
+      return c - MIN_CHAR_HEBREW + 0x20;
+    }
+  */
+  else if ((MIN_CHAR_THAI <= c) && (c <= MAX_CHAR_THAI))
+    {
+      *charset = Vcharset_thai_tis620;
+      return c - MIN_CHAR_THAI + 0x20;
+    }
+  /*
+  else if ((MIN_CHAR_HALFWIDTH_KATAKANA <= c)
+          && (c <= MAX_CHAR_HALFWIDTH_KATAKANA))
+    {
+      return list2 (Vcharset_katakana_jisx0201,
+                   make_int (c - MIN_CHAR_HALFWIDTH_KATAKANA + 33));
+    }
+  */
+  else if (c <= MAX_CHAR_BMP)
+    {
+      *charset = Vcharset_ucs_bmp;
+      return c;
+    }
+  else if (c < MIN_CHAR_DAIKANWA)
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+  else if (c <= MAX_CHAR_DAIKANWA)
+    {
+      *charset = Vcharset_ideograph_daikanwa;
+      return c - MIN_CHAR_DAIKANWA;
+    }
+  else if (c <= MAX_CHAR_MOJIKYO_0)
+    {
+      *charset = Vcharset_mojikyo;
+      return c - MIN_CHAR_MOJIKYO_0;
+    }
+  else if (c < MIN_CHAR_94)
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+  else if (c <= MAX_CHAR_94)
+    {
+      *charset = CHARSET_BY_ATTRIBUTES (94, 1,
+                                       ((c - MIN_CHAR_94) / 94) + '0',
+                                       CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+       return ((c - MIN_CHAR_94) % 94) + 33;
+      else
+       {
+         *charset = Vcharset_ucs;
+         return c;
+       }
+    }
+  else if (c <= MAX_CHAR_96)
+    {
+      *charset = CHARSET_BY_ATTRIBUTES (96, 1,
+                                       ((c - MIN_CHAR_96) / 96) + '0',
+                                       CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+       return ((c - MIN_CHAR_96) % 96) + 32;
+      else
+       {
+         *charset = Vcharset_ucs;
+         return c;
+       }
+    }
+  else if (c <= MAX_CHAR_94x94)
+    {
+      *charset
+       = CHARSET_BY_ATTRIBUTES (94, 2,
+                                ((c - MIN_CHAR_94x94) / (94 * 94)) + '0',
+                                CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+       return (((((c - MIN_CHAR_94x94) / 94) % 94) + 33) << 8)
+         | (((c - MIN_CHAR_94x94) % 94) + 33);
+      else
+       {
+         *charset = Vcharset_ucs;
+         return c;
+       }
+    }
+  else if (c <= MAX_CHAR_96x96)
+    {
+      *charset
+       = CHARSET_BY_ATTRIBUTES (96, 2,
+                                ((c - MIN_CHAR_96x96) / (96 * 96)) + '0',
+                                CHARSET_LEFT_TO_RIGHT);
+      if (!NILP (*charset))
+       return ((((c - MIN_CHAR_96x96) / 96) % 96) + 32) << 8
+         | (((c - MIN_CHAR_96x96) % 96) + 32);
+      else
+       {
+         *charset = Vcharset_ucs;
+         return c;
+       }
+    }
+  else if (c < MIN_CHAR_MOJIKYO)
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+  else if (c <= MAX_CHAR_MOJIKYO)
+    {
+      *charset = Vcharset_mojikyo;
+      return c - MIN_CHAR_MOJIKYO;
+    }
+  else if (c < MIN_CHAR_JEF_CHINA3)
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+  else if (c <= MAX_CHAR_JEF_CHINA3)
+    {
+      *charset = Vcharset_japanese_jef_china3;
+      return c - MAX_CHAR_JEF_CHINA3;
+    }
+  else
+    {
+      *charset = Vcharset_ucs;
+      return c;
+    }
+}
+
+Lisp_Object Vdefault_coded_charset_priority_list;
+#endif
+

 \f
 /************************************************************************/
 /*                      Basic charset Lisp functions                    */
 \f
 /************************************************************************/
 /*                      Basic charset Lisp functions                    */

@@ -609,7 +1391,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;
 
     (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;
 }
 
   return 0;
 }
 

@@ -632,13 +1414,14 @@ Return a list of the names of all defined charsets.
 }
 
 DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /*
 }
 
 DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /*

-Return the name of the given charset.
+Return the name of charset CHARSET.

 */
        (charset))
 {
   return XCHARSET_NAME (Fget_charset (charset));
 }
 
 */
        (charset))
 {
   return XCHARSET_NAME (Fget_charset (charset));
 }
 

+/* #### SJT Should generic properties be allowed? */

 DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /*
 Define a new character set.
 This function is for use with Mule support.
 DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /*
 Define a new character set.
 This function is for use with Mule support.

@@ -690,12 +1473,11 @@ character set.  Recognized properties are:
 {
   int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
   int direction = CHARSET_LEFT_TO_RIGHT;
 {
   int id, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
   int direction = CHARSET_LEFT_TO_RIGHT;

-  int type;

   Lisp_Object registry = Qnil;
   Lisp_Object charset;
   Lisp_Object registry = Qnil;
   Lisp_Object charset;

-  Lisp_Object rest, keyword, value;

   Lisp_Object ccl_program = Qnil;
   Lisp_Object short_name = Qnil, long_name = Qnil;
   Lisp_Object ccl_program = Qnil;
   Lisp_Object short_name = Qnil, long_name = Qnil;

+  int byte_offset = -1;

 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))
 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))

@@ -705,85 +1487,94 @@ character set.  Recognized properties are:
   if (!NILP (charset))
     signal_simple_error ("Cannot redefine existing charset", name);
 
   if (!NILP (charset))
     signal_simple_error ("Cannot redefine existing charset", name);
 

-  EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
-    {
-      if (EQ (keyword, Qshort_name))
-       {
-         CHECK_STRING (value);
-         short_name = value;
-       }
-
-      if (EQ (keyword, Qlong_name))
-       {
-         CHECK_STRING (value);
-         long_name = value;
-       }
-
-      else if (EQ (keyword, Qdimension))
-       {
-         CHECK_INT (value);
-         dimension = XINT (value);
-         if (dimension < 1 || dimension > 2)
-           signal_simple_error ("Invalid value for 'dimension", value);
-       }
-
-      else if (EQ (keyword, Qchars))
-       {
-         CHECK_INT (value);
-         chars = XINT (value);
-         if (chars != 94 && chars != 96)
-           signal_simple_error ("Invalid value for 'chars", value);
-       }
-
-      else if (EQ (keyword, Qcolumns))
-       {
-         CHECK_INT (value);
-         columns = XINT (value);
-         if (columns != 1 && columns != 2)
-           signal_simple_error ("Invalid value for 'columns", value);
-       }
-
-      else if (EQ (keyword, Qgraphic))
-       {
-         CHECK_INT (value);
-         graphic = XINT (value);
-         if (graphic < 0 || graphic > 1)
-           signal_simple_error ("Invalid value for 'graphic", value);
-       }
-
-      else if (EQ (keyword, Qregistry))
-       {
-         CHECK_STRING (value);
-         registry = value;
-       }
-
-      else if (EQ (keyword, Qdirection))
-       {
-         if (EQ (value, Ql2r))
-           direction = CHARSET_LEFT_TO_RIGHT;
-         else if (EQ (value, Qr2l))
-           direction = CHARSET_RIGHT_TO_LEFT;
-         else
-           signal_simple_error ("Invalid value for 'direction", value);
-       }
-
-      else if (EQ (keyword, Qfinal))
-       {
-         CHECK_CHAR_COERCE_INT (value);
-         final = XCHAR (value);
-         if (final < '0' || final > '~')
-           signal_simple_error ("Invalid value for 'final", value);
-       }
-
-      else if (EQ (keyword, Qccl_program))
-       {
-         CHECK_VECTOR (value);
-         ccl_program = value;
-       }
-
-      else
-       signal_simple_error ("Unrecognized property", keyword);
-    }
+  {
+    EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props)
+      {
+       if (EQ (keyword, Qshort_name))
+         {
+           CHECK_STRING (value);
+           short_name = value;
+         }
+
+       if (EQ (keyword, Qlong_name))
+         {
+           CHECK_STRING (value);
+           long_name = value;
+         }
+
+       else if (EQ (keyword, Qdimension))
+         {
+           CHECK_INT (value);
+           dimension = XINT (value);
+           if (dimension < 1 || dimension > 2)
+             signal_simple_error ("Invalid value for 'dimension", value);
+         }
+
+       else if (EQ (keyword, Qchars))
+         {
+           CHECK_INT (value);
+           chars = XINT (value);
+           if (chars != 94 && chars != 96)
+             signal_simple_error ("Invalid value for 'chars", value);
+         }
+
+       else if (EQ (keyword, Qcolumns))
+         {
+           CHECK_INT (value);
+           columns = XINT (value);
+           if (columns != 1 && columns != 2)
+             signal_simple_error ("Invalid value for 'columns", value);
+         }
+
+       else if (EQ (keyword, Qgraphic))
+         {
+           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);
+         }
+
+       else if (EQ (keyword, Qregistry))
+         {
+           CHECK_STRING (value);
+           registry = value;
+         }
+
+       else if (EQ (keyword, Qdirection))
+         {
+           if (EQ (value, Ql2r))
+             direction = CHARSET_LEFT_TO_RIGHT;
+           else if (EQ (value, Qr2l))
+             direction = CHARSET_RIGHT_TO_LEFT;
+           else
+             signal_simple_error ("Invalid value for 'direction", value);
+         }
+
+       else if (EQ (keyword, Qfinal))
+         {
+           CHECK_CHAR_COERCE_INT (value);
+           final = XCHAR (value);
+           if (final < '0' || final > '~')
+             signal_simple_error ("Invalid value for 'final", value);
+         }
+
+       else if (EQ (keyword, Qccl_program))
+         {
+           struct ccl_program test_ccl;
+
+           if (setup_ccl_program (&test_ccl, value) < 0)
+             signal_simple_error ("Invalid value for 'ccl-program", value);
+           ccl_program = value;
+         }
+
+       else
+         signal_simple_error ("Unrecognized property", keyword);
+      }
+  }

 
   if (!final)
     error ("'final must be specified");
 
   if (!final)
     error ("'final must be specified");

@@ -792,13 +1583,10 @@ character set.  Recognized properties are:
       ("Final must be in the range 0x30 - 0x5F for dimension == 2",
        make_char (final));
 
       ("Final must be in the range 0x30 - 0x5F for dimension == 2",
        make_char (final));
 

-  if (dimension == 1)
-    type = (chars == 94) ? CHARSET_TYPE_94    : CHARSET_TYPE_96;
-  else
-    type = (chars == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
-
-  if (!NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_LEFT_TO_RIGHT)) ||
-      !NILP (CHARSET_BY_ATTRIBUTES (type, final, CHARSET_RIGHT_TO_LEFT)))
+  if (!NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
+                                   CHARSET_LEFT_TO_RIGHT)) ||
+      !NILP (CHARSET_BY_ATTRIBUTES (chars, dimension, final,
+                                   CHARSET_RIGHT_TO_LEFT)))

     error
       ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
 
     error
       ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
 

@@ -818,8 +1606,21 @@ character set.  Recognized properties are:
 
   if (columns == -1)
     columns = dimension;
 
   if (columns == -1)
     columns = dimension;

-  charset = make_charset (id, name, dimension + 2, type, columns, graphic,
-                         final, direction, short_name, long_name, doc_string, registry);
+
+  if (byte_offset < 0)
+    {
+      if (chars == 94)
+       byte_offset = 33;
+      else if (chars == 96)
+       byte_offset = 32;
+      else
+       byte_offset = 0;
+    }
+
+  charset = make_charset (id, name, chars, dimension, columns, graphic,
+                         final, direction, short_name, long_name,
+                         doc_string, registry,
+                         Qnil, 0, 0, 0, byte_offset);

   if (!NILP (ccl_program))
     XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return charset;
   if (!NILP (ccl_program))
     XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return charset;

@@ -833,8 +1634,8 @@ NEW-NAME is the name of the new charset.  Return the new charset.
        (charset, new_name))
 {
   Lisp_Object new_charset = Qnil;
        (charset, new_name))
 {
   Lisp_Object new_charset = Qnil;

-  int id, dimension, columns, graphic, final;
-  int direction, type;
+  int id, chars, dimension, columns, graphic, final;
+  int direction;

   Lisp_Object registry, doc_string, short_name, long_name;
   Lisp_Charset *cs;
 
   Lisp_Object registry, doc_string, short_name, long_name;
   Lisp_Charset *cs;
 

@@ -849,9 +1650,9 @@ NEW-NAME is the name of the new charset.  Return the new charset.
 
   cs = XCHARSET (charset);
 
 
   cs = XCHARSET (charset);
 

-  type      = CHARSET_TYPE      (cs);
-  columns   = CHARSET_COLUMNS   (cs);
+  chars     = CHARSET_CHARS     (cs);

   dimension = CHARSET_DIMENSION (cs);
   dimension = CHARSET_DIMENSION (cs);

+  columns   = CHARSET_COLUMNS   (cs);

   id = get_unallocated_leading_byte (dimension);
 
   graphic = CHARSET_GRAPHIC (cs);
   id = get_unallocated_leading_byte (dimension);
 
   graphic = CHARSET_GRAPHIC (cs);

@@ -864,9 +1665,19 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   long_name = CHARSET_LONG_NAME (cs);
   registry = CHARSET_REGISTRY (cs);
 
   long_name = CHARSET_LONG_NAME (cs);
   registry = CHARSET_REGISTRY (cs);
 

-  new_charset = make_charset (id, new_name, dimension + 2, type, columns,
+  new_charset = make_charset (id, new_name, chars, dimension, columns,

                              graphic, final, direction, short_name, long_name,
                              graphic, final, direction, short_name, long_name,

-                             doc_string, registry);
+                             doc_string, registry,
+#ifdef UTF2000
+                             CHARSET_DECODING_TABLE(cs),
+                             CHARSET_UCS_MIN(cs),
+                             CHARSET_UCS_MAX(cs),
+                             CHARSET_CODE_OFFSET(cs),
+                             CHARSET_BYTE_OFFSET(cs)
+#else
+                             Qnil, 0, 0, 0, 0
+#endif
+);

 
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset;
   XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset;
 
   CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset;
   XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset;

@@ -874,6 +1685,16 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   return new_charset;
 }
 
   return new_charset;
 }
 

+DEFUN ("define-charset-alias", Fdefine_charset_alias, 2, 2, 0, /*
+Define symbol ALIAS as an alias for CHARSET.
+*/
+       (alias, charset))
+{
+  CHECK_SYMBOL (alias);
+  charset = Fget_charset (charset);
+  return Fputhash (alias, charset, Vcharset_hash_table);
+}
+

 /* #### Reverse direction charsets not yet implemented.  */
 #if 0
 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset,
 /* #### Reverse direction charsets not yet implemented.  */
 #if 0
 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset,

@@ -898,7 +1719,6 @@ will be returned if character sets exist for both directions).
        (dimension, chars, final, direction))
 {
   int dm, ch, fi, di = -1;
        (dimension, chars, final, direction))
 {
   int dm, ch, fi, di = -1;

-  int type;

   Lisp_Object obj = Qnil;
 
   CHECK_INT (dimension);
   Lisp_Object obj = Qnil;
 
   CHECK_INT (dimension);

@@ -927,19 +1747,14 @@ will be returned if character sets exist for both directions).
     signal_simple_error
       ("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
 
     signal_simple_error
       ("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
 

-  if (dm == 1)
-    type = (ch == 94) ? CHARSET_TYPE_94    : CHARSET_TYPE_96;
-  else
-    type = (ch == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96;
-
-  if (di == -1)
+    if (di == -1)

     {
     {

-      obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_LEFT_TO_RIGHT);
+      obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_LEFT_TO_RIGHT);

       if (NILP (obj))
       if (NILP (obj))

-       obj = CHARSET_BY_ATTRIBUTES (type, fi, CHARSET_RIGHT_TO_LEFT);
+       obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, CHARSET_RIGHT_TO_LEFT);

     }
   else
     }
   else

-    obj = CHARSET_BY_ATTRIBUTES (type, fi, di);
+    obj = CHARSET_BY_ATTRIBUTES (ch, dm, fi, di);

 
   if (CHARSETP (obj))
     return XCHARSET_NAME (obj);
 
   if (CHARSETP (obj))
     return XCHARSET_NAME (obj);

@@ -979,7 +1794,7 @@ Return dimension of CHARSET.
 }
 
 DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /*
 }
 
 DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /*

-Return property PROP of CHARSET.
+Return property PROP of CHARSET, a charset object or symbol naming a charset.

 Recognized properties are those listed in `make-charset', as well as
 'name and 'doc-string.
 */
 Recognized properties are those listed in `make-charset', as well as
 'name and 'doc-string.
 */

@@ -1007,10 +1822,8 @@ Recognized properties are those listed in `make-charset', as well as
   if (EQ (prop, Qreverse_direction_charset))
     {
       Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);
   if (EQ (prop, Qreverse_direction_charset))
     {
       Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);

-      if (NILP (obj))
-       return Qnil;
-      else
-       return XCHARSET_NAME (obj);
+      /* #### Is this translation OK?  If so, error checking sufficient? */
+      return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;

     }
   signal_simple_error ("Unrecognized charset property name", prop);
   return Qnil; /* not reached */
     }
   signal_simple_error ("Unrecognized charset property name", prop);
   return Qnil; /* not reached */

@@ -1032,8 +1845,11 @@ Set the 'ccl-program property of CHARSET to CCL-PROGRAM.
 */
        (charset, ccl_program))
 {
 */
        (charset, ccl_program))
 {

+  struct ccl_program test_ccl;
+

   charset = Fget_charset (charset);
   charset = Fget_charset (charset);

-  CHECK_VECTOR (ccl_program);
+  if (setup_ccl_program (&test_ccl, ccl_program) < 0)
+    signal_simple_error ("Invalid ccl-program", ccl_program);

   XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return Qnil;
 }
   XCHARSET_CCL_PROGRAM (charset) = ccl_program;
   return Qnil;
 }

@@ -1052,7 +1868,6 @@ invalidate_charset_font_caches (Lisp_Object charset)
     }
 }
 
     }
 }
 

-/* Japanese folks may want to (set-charset-registry 'ascii "jisx0201") */

 DEFUN ("set-charset-registry", Fset_charset_registry, 2, 2, 0, /*
 Set the 'registry property of CHARSET to REGISTRY.
 */
 DEFUN ("set-charset-registry", Fset_charset_registry, 2, 2, 0, /*
 Set the 'registry property of CHARSET to REGISTRY.
 */

@@ -1066,11 +1881,166 @@ Set the 'registry property of CHARSET to REGISTRY.
   return Qnil;
 }
 
   return Qnil;
 }
 

+#ifdef UTF2000
+DEFUN ("charset-mapping-table", Fcharset_mapping_table, 1, 1, 0, /*
+Return mapping-table of CHARSET.
+*/
+       (charset))
+{
+  return XCHARSET_DECODING_TABLE (Fget_charset (charset));
+}
+
+DEFUN ("set-charset-mapping-table", Fset_charset_mapping_table, 2, 2, 0, /*
+Set mapping-table of CHARSET to TABLE.
+*/
+       (charset, table))
+{
+  struct Lisp_Charset *cs;
+  size_t i;
+  int byte_offset;
+
+  charset = Fget_charset (charset);
+  cs = XCHARSET (charset);
+
+  if (NILP (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 = 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));
+
+  byte_offset = CHARSET_BYTE_OFFSET (cs);
+  switch (CHARSET_DIMENSION (cs))
+    {
+    case 1:
+      for (i = 0; i < XVECTOR_LENGTH (table); i++)
+       {
+         Lisp_Object c = XVECTOR_DATA(table)[i];
+
+         if (CHARP (c))
+           put_char_ccs_code_point (c, charset,
+                                    make_int (i + byte_offset));
+       }
+      break;
+    case 2:
+      for (i = 0; i < XVECTOR_LENGTH (table); i++)
+       {
+         Lisp_Object v = XVECTOR_DATA(table)[i];
+
+         if (VECTORP (v))
+           {
+             size_t j;
+
+             for (j = 0; j < XVECTOR_LENGTH (v); j++)
+               {
+                 Lisp_Object c = XVECTOR_DATA(v)[j];
+
+                 if (CHARP (c))
+                   put_char_ccs_code_point
+                     (c, charset,
+                      make_int ( ( (i + byte_offset) << 8 )
+                                 | (j + byte_offset)
+                                 ) );
+               }
+           }
+         else if (CHARP (v))
+           put_char_ccs_code_point (v, charset,
+                                    make_int (i + byte_offset));
+       }
+      break;
+    }
+  return table;
+}
+#endif
+

 \f
 /************************************************************************/
 /*              Lisp primitives for working with characters             */
 /************************************************************************/
 
 \f
 /************************************************************************/
 /*              Lisp primitives for working with characters             */
 /************************************************************************/
 

+#ifdef UTF2000
+DEFUN ("decode-char", Fdecode_char, 2, 2, 0, /*
+Make a character from CHARSET and code-point CODE.
+*/
+       (charset, code))
+{
+  int c;
+
+  charset = Fget_charset (charset);
+  CHECK_INT (code);
+  c = XINT (code);
+  if (XCHARSET_GRAPHIC (charset) == 1)
+    c &= 0x7F7F7F7F;
+  c = DECODE_CHAR (charset, c);
+  return c >= 0 ? make_char (c) : Qnil;
+}
+
+DEFUN ("decode-builtin-char", Fdecode_builtin_char, 2, 2, 0, /*
+Make a builtin character from CHARSET and code-point CODE.
+*/
+       (charset, code))
+{
+  int c;
+
+  charset = Fget_charset (charset);
+  CHECK_INT (code);
+  if (EQ (charset, Vcharset_latin_viscii))
+    {
+      Lisp_Object chr = Fdecode_char (charset, code);
+      Lisp_Object ret;
+
+      if (!NILP (chr))
+       {
+         if (!NILP
+             (ret = Fget_char_attribute (chr,
+                                         Vcharset_latin_viscii_lower,
+                                         Qnil)))
+           {
+             charset = Vcharset_latin_viscii_lower;
+             code = ret;
+           }
+         else if (!NILP
+                  (ret = Fget_char_attribute (chr,
+                                              Vcharset_latin_viscii_upper,
+                                              Qnil)))
+           {
+             charset = Vcharset_latin_viscii_upper;
+             code = ret;
+           }
+       }
+    }
+  c = XINT (code);
+#if 0
+  if (XCHARSET_GRAPHIC (charset) == 1)
+    c &= 0x7F7F7F7F;
+#endif
+  c = decode_builtin_char (charset, c);
+  return c >= 0 ? make_char (c) : Fdecode_char (charset, code);
+}
+#endif
+

 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
 Make a character from CHARSET and octets ARG1 and ARG2.
 ARG2 is required only for characters from two-dimensional charsets.
 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
 Make a character from CHARSET and octets ARG1 and ARG2.
 ARG2 is required only for characters from two-dimensional charsets.

@@ -1088,15 +2058,24 @@ character s with caron.
 
   if      (EQ (charset, Vcharset_ascii))     lowlim =  0, highlim = 127;
   else if (EQ (charset, Vcharset_control_1)) lowlim =  0, highlim =  31;
 
   if      (EQ (charset, Vcharset_ascii))     lowlim =  0, highlim = 127;
   else if (EQ (charset, Vcharset_control_1)) lowlim =  0, highlim =  31;

+#ifdef UTF2000
+  else if (CHARSET_CHARS (cs) == 256)        lowlim =  0, highlim = 255;
+#endif

   else if (CHARSET_CHARS (cs) == 94)         lowlim = 33, highlim = 126;
   else /* CHARSET_CHARS (cs) == 96) */      lowlim = 32, highlim = 127;
 
   CHECK_INT (arg1);
   /* It is useful (and safe, according to Olivier Galibert) to strip
   else if (CHARSET_CHARS (cs) == 94)         lowlim = 33, highlim = 126;
   else /* CHARSET_CHARS (cs) == 96) */      lowlim = 32, highlim = 127;
 
   CHECK_INT (arg1);
   /* It is useful (and safe, according to Olivier Galibert) to strip

-     the 8th bit off ARG1 and ARG2 becaue it allows programmers to
+     the 8th bit off ARG1 and ARG2 because it allows programmers to

      write (make-char 'latin-iso8859-2 CODE) where code is the actual
      Latin 2 code of the character.  */
      write (make-char 'latin-iso8859-2 CODE) where code is the actual
      Latin 2 code of the character.  */

-  a1 = XINT (arg1) & 0x7f;
+#ifdef UTF2000
+  a1 = XINT (arg1);
+  if (highlim < 128)
+    a1 &= 0x7f;
+#else
+  a1 = XINT (arg1);
+#endif

   if (a1 < lowlim || a1 > highlim)
     args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
 
   if (a1 < lowlim || a1 > highlim)
     args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
 

@@ -1109,7 +2088,13 @@ character s with caron.
     }
 
   CHECK_INT (arg2);
     }
 
   CHECK_INT (arg2);

+#ifdef UTF2000
+  a2 = XINT (arg2);
+  if (highlim < 128)
+    a2 &= 0x7f;
+#else

   a2 = XINT (arg2) & 0x7f;
   a2 = XINT (arg2) & 0x7f;

+#endif

   if (a2 < lowlim || a2 > highlim)
     args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim));
 
   if (a2 < lowlim || a2 > highlim)
     args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim));
 

@@ -1117,28 +2102,27 @@ character s with caron.
 }
 
 DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /*
 }
 
 DEFUN ("char-charset", Fchar_charset, 1, 1, 0, /*

-Return the character set of char CH.
+Return the character set of CHARACTER.

 */
 */

-       (ch))
+       (character))

 {
 {

-  CHECK_CHAR_COERCE_INT (ch);
+  CHECK_CHAR_COERCE_INT (character);

 
 

-  return XCHARSET_NAME (CHARSET_BY_LEADING_BYTE
-                       (CHAR_LEADING_BYTE (XCHAR (ch))));
+  return XCHARSET_NAME (CHAR_CHARSET (XCHAR (character)));

 }
 
 DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*
 }
 
 DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*

-Return the octet numbered N (should be 0 or 1) of char CH.
+Return the octet numbered N (should be 0 or 1) of CHARACTER.

 N defaults to 0 if omitted.
 */
 N defaults to 0 if omitted.
 */

-       (ch, n))
+       (character, n))

 {
   Lisp_Object charset;
   int octet0, octet1;
 
 {
   Lisp_Object charset;
   int octet0, octet1;
 

-  CHECK_CHAR_COERCE_INT (ch);
+  CHECK_CHAR_COERCE_INT (character);

 
 

-  BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1);
+  BREAKUP_CHAR (XCHAR (character), charset, octet0, octet1);

 
   if (NILP (n) || EQ (n, Qzero))
     return make_int (octet0);
 
   if (NILP (n) || EQ (n, Qzero))
     return make_int (octet0);

@@ -1149,7 +2133,7 @@ N defaults to 0 if omitted.
 }
 
 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
 }
 
 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*

-Return list of charset and one or two position-codes of CHAR.
+Return list of charset and one or two position-codes of CHARACTER.

 */
        (character))
 {
 */
        (character))
 {

@@ -1157,11 +2141,27 @@ Return list of charset and one or two position-codes of CHAR.
   struct gcpro gcpro1, gcpro2;
   Lisp_Object charset = Qnil;
   Lisp_Object rc = Qnil;
   struct gcpro gcpro1, gcpro2;
   Lisp_Object charset = Qnil;
   Lisp_Object rc = Qnil;

+#ifdef UTF2000
+  int code_point;
+  int dimension;
+#else

   int c1, c2;
   int c1, c2;

+#endif

 
   GCPRO2 (charset, rc);
   CHECK_CHAR_COERCE_INT (character);
 
 
   GCPRO2 (charset, rc);
   CHECK_CHAR_COERCE_INT (character);
 

+#ifdef UTF2000
+  code_point = ENCODE_CHAR (XCHAR (character), charset);
+  dimension = XCHARSET_DIMENSION (charset);
+  while (dimension > 0)
+    {
+      rc = Fcons (make_int (code_point & 255), rc);
+      code_point >>= 8;
+      dimension--;
+    }
+  rc = Fcons (XCHARSET_NAME (charset), rc);
+#else

   BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
 
   if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
   BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
 
   if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)

@@ -1172,6 +2172,7 @@ Return list of charset and one or two position-codes of CHAR.
     {
       rc = list2 (XCHARSET_NAME (charset), make_int (c1));
     }
     {
       rc = list2 (XCHARSET_NAME (charset), make_int (c1));
     }

+#endif

   UNGCPRO;
 
   return rc;
   UNGCPRO;
 
   return rc;

@@ -1259,6 +2260,8 @@ Return a string of the characters comprising a composite character.
 void
 syms_of_mule_charset (void)
 {
 void
 syms_of_mule_charset (void)
 {

+  INIT_LRECORD_IMPLEMENTATION (charset);
+

   DEFSUBR (Fcharsetp);
   DEFSUBR (Ffind_charset);
   DEFSUBR (Fget_charset);
   DEFSUBR (Fcharsetp);
   DEFSUBR (Ffind_charset);
   DEFSUBR (Fget_charset);

@@ -1267,6 +2270,7 @@ syms_of_mule_charset (void)
   DEFSUBR (Fmake_charset);
   DEFSUBR (Fmake_reverse_direction_charset);
   /*  DEFSUBR (Freverse_direction_charset); */
   DEFSUBR (Fmake_charset);
   DEFSUBR (Fmake_reverse_direction_charset);
   /*  DEFSUBR (Freverse_direction_charset); */

+  DEFSUBR (Fdefine_charset_alias);

   DEFSUBR (Fcharset_from_attributes);
   DEFSUBR (Fcharset_short_name);
   DEFSUBR (Fcharset_long_name);
   DEFSUBR (Fcharset_from_attributes);
   DEFSUBR (Fcharset_short_name);
   DEFSUBR (Fcharset_long_name);

@@ -1276,7 +2280,15 @@ syms_of_mule_charset (void)
   DEFSUBR (Fcharset_id);
   DEFSUBR (Fset_charset_ccl_program);
   DEFSUBR (Fset_charset_registry);
   DEFSUBR (Fcharset_id);
   DEFSUBR (Fset_charset_ccl_program);
   DEFSUBR (Fset_charset_registry);

+#ifdef UTF2000
+  DEFSUBR (Fcharset_mapping_table);
+  DEFSUBR (Fset_charset_mapping_table);
+#endif

 
 

+#ifdef UTF2000
+  DEFSUBR (Fdecode_char);
+  DEFSUBR (Fdecode_builtin_char);
+#endif

   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
   DEFSUBR (Fchar_octet);
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
   DEFSUBR (Fchar_octet);

@@ -1317,11 +2329,66 @@ syms_of_mule_charset (void)
   defsymbol (&Qlatin_iso8859_9,                "latin-iso8859-9");
   defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
   defsymbol (&Qchinese_gb2312,         "chinese-gb2312");
   defsymbol (&Qlatin_iso8859_9,                "latin-iso8859-9");
   defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
   defsymbol (&Qchinese_gb2312,         "chinese-gb2312");

+  defsymbol (&Qchinese_gb12345,                "chinese-gb12345");

   defsymbol (&Qjapanese_jisx0208,      "japanese-jisx0208");
   defsymbol (&Qjapanese_jisx0208,      "japanese-jisx0208");

+  defsymbol (&Qjapanese_jisx0208_1990,         "japanese-jisx0208-1990");

   defsymbol (&Qkorean_ksc5601,         "korean-ksc5601");
   defsymbol (&Qjapanese_jisx0212,      "japanese-jisx0212");
   defsymbol (&Qchinese_cns11643_1,     "chinese-cns11643-1");
   defsymbol (&Qchinese_cns11643_2,     "chinese-cns11643-2");
   defsymbol (&Qkorean_ksc5601,         "korean-ksc5601");
   defsymbol (&Qjapanese_jisx0212,      "japanese-jisx0212");
   defsymbol (&Qchinese_cns11643_1,     "chinese-cns11643-1");
   defsymbol (&Qchinese_cns11643_2,     "chinese-cns11643-2");

+#ifdef UTF2000
+  defsymbol (&Qucs,                    "ucs");
+  defsymbol (&Qucs_bmp,                        "ucs-bmp");
+  defsymbol (&Qucs_cns,                        "ucs-cns");
+  defsymbol (&Qucs_jis,                        "ucs-jis");
+  defsymbol (&Qucs_big5,               "ucs-big5");
+  defsymbol (&Qlatin_viscii,           "latin-viscii");
+  defsymbol (&Qlatin_tcvn5712,         "latin-tcvn5712");
+  defsymbol (&Qlatin_viscii_lower,     "latin-viscii-lower");
+  defsymbol (&Qlatin_viscii_upper,     "latin-viscii-upper");
+  defsymbol (&Qvietnamese_viscii_lower,        "vietnamese-viscii-lower");
+  defsymbol (&Qvietnamese_viscii_upper,        "vietnamese-viscii-upper");
+  defsymbol (&Qideograph_gt,           "ideograph-gt");
+  defsymbol (&Qideograph_gt_pj_1,      "ideograph-gt-pj-1");
+  defsymbol (&Qideograph_gt_pj_2,      "ideograph-gt-pj-2");
+  defsymbol (&Qideograph_gt_pj_3,      "ideograph-gt-pj-3");
+  defsymbol (&Qideograph_gt_pj_4,      "ideograph-gt-pj-4");
+  defsymbol (&Qideograph_gt_pj_5,      "ideograph-gt-pj-5");
+  defsymbol (&Qideograph_gt_pj_6,      "ideograph-gt-pj-6");
+  defsymbol (&Qideograph_gt_pj_7,      "ideograph-gt-pj-7");
+  defsymbol (&Qideograph_gt_pj_8,      "ideograph-gt-pj-8");
+  defsymbol (&Qideograph_gt_pj_9,      "ideograph-gt-pj-9");
+  defsymbol (&Qideograph_gt_pj_10,     "ideograph-gt-pj-10");
+  defsymbol (&Qideograph_gt_pj_11,     "ideograph-gt-pj-11");
+  defsymbol (&Qideograph_daikanwa,     "ideograph-daikanwa");
+  defsymbol (&Qchinese_big5,           "chinese-big5");
+  defsymbol (&Qchinese_big5_cdp,       "chinese-big5-cdp");
+  defsymbol (&Qjapanese_jef_china3,    "japanese-jef-china3");
+  defsymbol (&Qmojikyo,                        "mojikyo");
+  defsymbol (&Qmojikyo_2022_1,         "mojikyo-2022-1");
+  defsymbol (&Qmojikyo_pj_1,           "mojikyo-pj-1");
+  defsymbol (&Qmojikyo_pj_2,           "mojikyo-pj-2");
+  defsymbol (&Qmojikyo_pj_3,           "mojikyo-pj-3");
+  defsymbol (&Qmojikyo_pj_4,           "mojikyo-pj-4");
+  defsymbol (&Qmojikyo_pj_5,           "mojikyo-pj-5");
+  defsymbol (&Qmojikyo_pj_6,           "mojikyo-pj-6");
+  defsymbol (&Qmojikyo_pj_7,           "mojikyo-pj-7");
+  defsymbol (&Qmojikyo_pj_8,           "mojikyo-pj-8");
+  defsymbol (&Qmojikyo_pj_9,           "mojikyo-pj-9");
+  defsymbol (&Qmojikyo_pj_10,          "mojikyo-pj-10");
+  defsymbol (&Qmojikyo_pj_11,          "mojikyo-pj-11");
+  defsymbol (&Qmojikyo_pj_12,          "mojikyo-pj-12");
+  defsymbol (&Qmojikyo_pj_13,          "mojikyo-pj-13");
+  defsymbol (&Qmojikyo_pj_14,          "mojikyo-pj-14");
+  defsymbol (&Qmojikyo_pj_15,          "mojikyo-pj-15");
+  defsymbol (&Qmojikyo_pj_16,          "mojikyo-pj-16");
+  defsymbol (&Qmojikyo_pj_17,          "mojikyo-pj-17");
+  defsymbol (&Qmojikyo_pj_18,          "mojikyo-pj-18");
+  defsymbol (&Qmojikyo_pj_19,          "mojikyo-pj-19");
+  defsymbol (&Qmojikyo_pj_20,          "mojikyo-pj-20");
+  defsymbol (&Qmojikyo_pj_21,          "mojikyo-pj-21");
+  defsymbol (&Qethiopic_ucs,           "ethiopic-ucs");
+#endif

   defsymbol (&Qchinese_big5_1,         "chinese-big5-1");
   defsymbol (&Qchinese_big5_2,         "chinese-big5-2");
 
   defsymbol (&Qchinese_big5_1,         "chinese-big5-1");
   defsymbol (&Qchinese_big5_2,         "chinese-big5-2");
 

@@ -1331,23 +2398,53 @@ syms_of_mule_charset (void)
 void
 vars_of_mule_charset (void)
 {
 void
 vars_of_mule_charset (void)
 {

-  int i, j, k;
+  int i, j;
+#ifndef UTF2000
+  int k;
+#endif

 
 

-  chlook = xnew (struct charset_lookup);
-  dumpstruct (&chlook, &charset_lookup_description);
+  chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */
+  dump_add_root_struct_ptr (&chlook, &charset_lookup_description);

 
   /* Table of charsets indexed by leading byte. */
   for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
     chlook->charset_by_leading_byte[i] = Qnil;
 
 
   /* Table of charsets indexed by leading byte. */
   for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
     chlook->charset_by_leading_byte[i] = Qnil;
 

+#ifdef UTF2000
+  /* Table of charsets indexed by type/final-byte. */
+  for (i = 0; i < countof (chlook->charset_by_attributes); i++)
+    for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
+      chlook->charset_by_attributes[i][j] = Qnil;
+#else

   /* Table of charsets indexed by type/final-byte/direction. */
   for (i = 0; i < countof (chlook->charset_by_attributes); i++)
     for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
       for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++)
        chlook->charset_by_attributes[i][j][k] = Qnil;
   /* Table of charsets indexed by type/final-byte/direction. */
   for (i = 0; i < countof (chlook->charset_by_attributes); i++)
     for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++)
       for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++)
        chlook->charset_by_attributes[i][j][k] = Qnil;

+#endif

 
 

-  next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
-  next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
+#ifdef UTF2000
+  chlook->next_allocated_leading_byte = MIN_LEADING_BYTE_PRIVATE;
+#else
+  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
+  leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
+  DEFVAR_INT ("leading-code-private-11", &leading_code_private_11 /*
+Leading-code of private TYPE9N charset of column-width 1.
+*/ );
+  leading_code_private_11 = PRE_LEADING_BYTE_PRIVATE_1;
+#endif
+
+#ifdef UTF2000
+  Vdefault_coded_charset_priority_list = Qnil;
+  DEFVAR_LISP ("default-coded-charset-priority-list",
+              &Vdefault_coded_charset_priority_list /*
+Default order of preferred coded-character-sets.
+*/ );
+#endif

 }
 
 void
 }
 
 void

@@ -1360,221 +2457,469 @@ complex_vars_of_mule_charset (void)
   /* Predefined character sets.  We store them into variables for
      ease of access. */
 
   /* Predefined character sets.  We store them into variables for
      ease of access. */
 

+#ifdef UTF2000
+  staticpro (&Vcharset_ucs);
+  Vcharset_ucs =
+    make_charset (LEADING_BYTE_UCS, Qucs, 256, 4,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("UCS"),
+                 build_string ("UCS"),
+                 build_string ("ISO/IEC 10646"),
+                 build_string (""),
+                 Qnil, 0, 0xFFFFFFF, 0, 0);
+  staticpro (&Vcharset_ucs_bmp);
+  Vcharset_ucs_bmp =
+    make_charset (LEADING_BYTE_UCS_BMP, Qucs_bmp, 256, 2,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("BMP"),
+                 build_string ("BMP"),
+                 build_string ("ISO/IEC 10646 Group 0 Plane 0 (BMP)"),
+                 build_string ("\\(ISO10646.*-1\\|UNICODE[23]?-0\\)"),
+                 Qnil, 0, 0xFFFF, 0, 0);
+  staticpro (&Vcharset_ucs_cns);
+  Vcharset_ucs_cns =
+    make_charset (LEADING_BYTE_UCS_CNS, Qucs_cns, 256, 3,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("UCS for CNS"),
+                 build_string ("UCS for CNS 11643"),
+                 build_string ("ISO/IEC 10646 for CNS 11643"),
+                 build_string (""),
+                 Qnil, 0, 0, 0, 0);
+  staticpro (&Vcharset_ucs_jis);
+  Vcharset_ucs_jis =
+    make_charset (LEADING_BYTE_UCS_JIS, Qucs_jis, 256, 3,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("UCS for JIS"),
+                 build_string ("UCS for JIS X 0208, 0212 and 0213"),
+                 build_string ("ISO/IEC 10646 for JIS X 0208, 0212 and 0213"),
+                 build_string (""),
+                 Qnil, 0, 0, 0, 0);
+  staticpro (&Vcharset_ucs_big5);
+  Vcharset_ucs_big5 =
+    make_charset (LEADING_BYTE_UCS_BIG5, Qucs_big5, 256, 3,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("UCS for Big5"),
+                 build_string ("UCS for Big5"),
+                 build_string ("ISO/IEC 10646 for Big5"),
+                 build_string (""),
+                 Qnil, 0, 0, 0, 0);
+#else
+# define MIN_CHAR_THAI 0
+# define MAX_CHAR_THAI 0
+  /* # define MIN_CHAR_HEBREW 0 */
+  /* # define MAX_CHAR_HEBREW 0 */
+# define MIN_CHAR_HALFWIDTH_KATAKANA 0
+# define MAX_CHAR_HALFWIDTH_KATAKANA 0
+#endif

   staticpro (&Vcharset_ascii);
   Vcharset_ascii =
   staticpro (&Vcharset_ascii);
   Vcharset_ascii =

-    make_charset (LEADING_BYTE_ASCII, Qascii, 1,
-                 CHARSET_TYPE_94, 1, 0, 'B',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_ASCII, Qascii, 94, 1,
+                 1, 0, 'B', CHARSET_LEFT_TO_RIGHT,

                  build_string ("ASCII"),
                  build_string ("ASCII)"),
                  build_string ("ASCII (ISO646 IRV)"),
                  build_string ("ASCII"),
                  build_string ("ASCII)"),
                  build_string ("ASCII (ISO646 IRV)"),

-                 build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"));
+                 build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"),
+                 Qnil, 0, 0x7F, 0, 0);

   staticpro (&Vcharset_control_1);
   Vcharset_control_1 =
   staticpro (&Vcharset_control_1);
   Vcharset_control_1 =

-    make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 2,
-                 CHARSET_TYPE_94, 1, 1, 0,
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 94, 1,
+                 1, 1, 0, CHARSET_LEFT_TO_RIGHT,

                  build_string ("C1"),
                  build_string ("Control characters"),
                  build_string ("Control characters 128-191"),
                  build_string ("C1"),
                  build_string ("Control characters"),
                  build_string ("Control characters 128-191"),

-                 build_string (""));
+                 build_string (""),
+                 Qnil, 0x80, 0x9F, 0, 0);

   staticpro (&Vcharset_latin_iso8859_1);
   Vcharset_latin_iso8859_1 =
   staticpro (&Vcharset_latin_iso8859_1);
   Vcharset_latin_iso8859_1 =

-    make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 2,
-                 CHARSET_TYPE_96, 1, 1, 'A',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 96, 1,
+                 1, 1, 'A', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Latin-1"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("Latin-1"),
                  build_string ("ISO8859-1 (Latin-1)"),
                  build_string ("ISO8859-1 (Latin-1)"),

-                 build_string ("iso8859-1"));
+                 build_string ("iso8859-1"),
+                 Qnil, 0xA0, 0xFF, 0, 32);

   staticpro (&Vcharset_latin_iso8859_2);
   Vcharset_latin_iso8859_2 =
   staticpro (&Vcharset_latin_iso8859_2);
   Vcharset_latin_iso8859_2 =

-    make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 2,
-                 CHARSET_TYPE_96, 1, 1, 'B',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 96, 1,
+                 1, 1, 'B', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Latin-2"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("Latin-2"),
                  build_string ("ISO8859-2 (Latin-2)"),
                  build_string ("ISO8859-2 (Latin-2)"),

-                 build_string ("iso8859-2"));
+                 build_string ("iso8859-2"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_latin_iso8859_3);
   Vcharset_latin_iso8859_3 =
   staticpro (&Vcharset_latin_iso8859_3);
   Vcharset_latin_iso8859_3 =

-    make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 2,
-                 CHARSET_TYPE_96, 1, 1, 'C',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 96, 1,
+                 1, 1, 'C', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Latin-3"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("Latin-3"),
                  build_string ("ISO8859-3 (Latin-3)"),
                  build_string ("ISO8859-3 (Latin-3)"),

-                 build_string ("iso8859-3"));
+                 build_string ("iso8859-3"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_latin_iso8859_4);
   Vcharset_latin_iso8859_4 =
   staticpro (&Vcharset_latin_iso8859_4);
   Vcharset_latin_iso8859_4 =

-    make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 2,
-                 CHARSET_TYPE_96, 1, 1, 'D',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 96, 1,
+                 1, 1, 'D', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Latin-4"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("Latin-4"),
                  build_string ("ISO8859-4 (Latin-4)"),
                  build_string ("ISO8859-4 (Latin-4)"),

-                 build_string ("iso8859-4"));
+                 build_string ("iso8859-4"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =
   staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =

-    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2,
-                 CHARSET_TYPE_96, 1, 1, 'T',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 96, 1,
+                 1, 1, 'T', CHARSET_LEFT_TO_RIGHT,

                  build_string ("TIS620"),
                  build_string ("TIS620 (Thai)"),
                  build_string ("TIS620.2529 (Thai)"),
                  build_string ("TIS620"),
                  build_string ("TIS620 (Thai)"),
                  build_string ("TIS620.2529 (Thai)"),

-                 build_string ("tis620"));
+                 build_string ("tis620"),
+                 Qnil, MIN_CHAR_THAI, MAX_CHAR_THAI, 0, 32);

   staticpro (&Vcharset_greek_iso8859_7);
   Vcharset_greek_iso8859_7 =
   staticpro (&Vcharset_greek_iso8859_7);
   Vcharset_greek_iso8859_7 =

-    make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 2,
-                 CHARSET_TYPE_96, 1, 1, 'F',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 96, 1,
+                 1, 1, 'F', CHARSET_LEFT_TO_RIGHT,

                  build_string ("ISO8859-7"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("ISO8859-7"),
                  build_string ("ISO8859-7 (Greek)"),
                  build_string ("ISO8859-7 (Greek)"),

-                 build_string ("iso8859-7"));
+                 build_string ("iso8859-7"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_arabic_iso8859_6);
   Vcharset_arabic_iso8859_6 =
   staticpro (&Vcharset_arabic_iso8859_6);
   Vcharset_arabic_iso8859_6 =

-    make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 2,
-                 CHARSET_TYPE_96, 1, 1, 'G',
-                 CHARSET_RIGHT_TO_LEFT,
+    make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 96, 1,
+                 1, 1, 'G', CHARSET_RIGHT_TO_LEFT,

                  build_string ("ISO8859-6"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("ISO8859-6"),
                  build_string ("ISO8859-6 (Arabic)"),
                  build_string ("ISO8859-6 (Arabic)"),

-                 build_string ("iso8859-6"));
+                 build_string ("iso8859-6"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_hebrew_iso8859_8);
   Vcharset_hebrew_iso8859_8 =
   staticpro (&Vcharset_hebrew_iso8859_8);
   Vcharset_hebrew_iso8859_8 =

-    make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 2,
-                 CHARSET_TYPE_96, 1, 1, 'H',
-                 CHARSET_RIGHT_TO_LEFT,
+    make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 96, 1,
+                 1, 1, 'H', CHARSET_RIGHT_TO_LEFT,

                  build_string ("ISO8859-8"),
                  build_string ("ISO8859-8 (Hebrew)"),
                  build_string ("ISO8859-8 (Hebrew)"),
                  build_string ("ISO8859-8"),
                  build_string ("ISO8859-8 (Hebrew)"),
                  build_string ("ISO8859-8 (Hebrew)"),

-                 build_string ("iso8859-8"));
+                 build_string ("iso8859-8"),
+                 Qnil,
+                 0 /* MIN_CHAR_HEBREW */,
+                 0 /* MAX_CHAR_HEBREW */, 0, 32);

   staticpro (&Vcharset_katakana_jisx0201);
   Vcharset_katakana_jisx0201 =
   staticpro (&Vcharset_katakana_jisx0201);
   Vcharset_katakana_jisx0201 =

-    make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 2,
-                 CHARSET_TYPE_94, 1, 1, 'I',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 94, 1,
+                 1, 1, 'I', CHARSET_LEFT_TO_RIGHT,

                  build_string ("JISX0201 Kana"),
                  build_string ("JISX0201.1976 (Japanese Kana)"),
                  build_string ("JISX0201.1976 Japanese Kana"),
                  build_string ("JISX0201 Kana"),
                  build_string ("JISX0201.1976 (Japanese Kana)"),
                  build_string ("JISX0201.1976 Japanese Kana"),

-                 build_string ("jisx0201.1976"));
+                 build_string ("jisx0201\\.1976"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_latin_jisx0201);
   Vcharset_latin_jisx0201 =
   staticpro (&Vcharset_latin_jisx0201);
   Vcharset_latin_jisx0201 =

-    make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2,
-                 CHARSET_TYPE_94, 1, 0, 'J',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 94, 1,
+                 1, 0, 'J', CHARSET_LEFT_TO_RIGHT,

                  build_string ("JISX0201 Roman"),
                  build_string ("JISX0201.1976 (Japanese Roman)"),
                  build_string ("JISX0201.1976 Japanese Roman"),
                  build_string ("JISX0201 Roman"),
                  build_string ("JISX0201.1976 (Japanese Roman)"),
                  build_string ("JISX0201.1976 Japanese Roman"),

-                 build_string ("jisx0201.1976"));
+                 build_string ("jisx0201\\.1976"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_cyrillic_iso8859_5);
   Vcharset_cyrillic_iso8859_5 =
   staticpro (&Vcharset_cyrillic_iso8859_5);
   Vcharset_cyrillic_iso8859_5 =

-    make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 2,
-                 CHARSET_TYPE_96, 1, 1, 'L',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 96, 1,
+                 1, 1, 'L', CHARSET_LEFT_TO_RIGHT,

                  build_string ("ISO8859-5"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("ISO8859-5"),
                  build_string ("ISO8859-5 (Cyrillic)"),
                  build_string ("ISO8859-5 (Cyrillic)"),

-                 build_string ("iso8859-5"));
+                 build_string ("iso8859-5"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_latin_iso8859_9);
   Vcharset_latin_iso8859_9 =
   staticpro (&Vcharset_latin_iso8859_9);
   Vcharset_latin_iso8859_9 =

-    make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 2,
-                 CHARSET_TYPE_96, 1, 1, 'M',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 96, 1,
+                 1, 1, 'M', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Latin-5"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("Latin-5"),
                  build_string ("ISO8859-9 (Latin-5)"),
                  build_string ("ISO8859-9 (Latin-5)"),

-                 build_string ("iso8859-9"));
+                 build_string ("iso8859-9"),
+                 Qnil, 0, 0, 0, 32);

   staticpro (&Vcharset_japanese_jisx0208_1978);
   Vcharset_japanese_jisx0208_1978 =
   staticpro (&Vcharset_japanese_jisx0208_1978);
   Vcharset_japanese_jisx0208_1978 =

-    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, 3,
-                 CHARSET_TYPE_94X94, 2, 0, '@',
-                 CHARSET_LEFT_TO_RIGHT,
-                 build_string ("JISX0208.1978"),
-                 build_string ("JISX0208.1978 (Japanese)"),
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978,
+                 Qjapanese_jisx0208_1978, 94, 2,
+                 2, 0, '@', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("JIS X0208:1978"),
+                 build_string ("JIS X0208:1978 (Japanese)"),

                  build_string
                  build_string

-                 ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"),
-                 build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"));
+                 ("JIS X0208:1978 Japanese Kanji (so called \"old JIS\")"),
+                 build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_chinese_gb2312);
   Vcharset_chinese_gb2312 =
   staticpro (&Vcharset_chinese_gb2312);
   Vcharset_chinese_gb2312 =

-    make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'A',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 94, 2,
+                 2, 0, 'A', CHARSET_LEFT_TO_RIGHT,

                  build_string ("GB2312"),
                  build_string ("GB2312)"),
                  build_string ("GB2312 Chinese simplified"),
                  build_string ("GB2312"),
                  build_string ("GB2312)"),
                  build_string ("GB2312 Chinese simplified"),

-                 build_string ("gb2312"));
+                 build_string ("gb2312"),
+                 Qnil, 0, 0, 0, 33);
+  staticpro (&Vcharset_chinese_gb12345);
+  Vcharset_chinese_gb12345 =
+    make_charset (LEADING_BYTE_CHINESE_GB12345, Qchinese_gb12345, 94, 2,
+                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("G1"),
+                 build_string ("GB 12345)"),
+                 build_string ("GB 12345-1990"),
+                 build_string ("GB12345\\(\\.1990\\)?-0"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_japanese_jisx0208);
   Vcharset_japanese_jisx0208 =
   staticpro (&Vcharset_japanese_jisx0208);
   Vcharset_japanese_jisx0208 =

-    make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'B',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 94, 2,
+                 2, 0, 'B', CHARSET_LEFT_TO_RIGHT,

                  build_string ("JISX0208"),
                  build_string ("JISX0208"),

-                 build_string ("JISX0208.1983/1990 (Japanese)"),
-                 build_string ("JISX0208.1983/1990 Japanese Kanji"),
-                 build_string ("jisx0208.19\\(83\\|90\\)"));
+                 build_string ("JIS X0208:1983 (Japanese)"),
+                 build_string ("JIS X0208:1983 Japanese Kanji"),
+                 build_string ("jisx0208\\.1983"),
+                 Qnil, 0, 0, 0, 33);
+#ifdef UTF2000
+  staticpro (&Vcharset_japanese_jisx0208_1990);
+  Vcharset_japanese_jisx0208_1990 =
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1990,
+                 Qjapanese_jisx0208_1990, 94, 2,
+                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("JISX0208-1990"),
+                 build_string ("JIS X0208:1990 (Japanese)"),
+                 build_string ("JIS X0208:1990 Japanese Kanji"),
+                 build_string ("jisx0208\\.1990"),
+                 Qnil,
+                 MIN_CHAR_JIS_X0208_1990,
+                 MAX_CHAR_JIS_X0208_1990, 0, 33);
+#endif

   staticpro (&Vcharset_korean_ksc5601);
   Vcharset_korean_ksc5601 =
   staticpro (&Vcharset_korean_ksc5601);
   Vcharset_korean_ksc5601 =

-    make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'C',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 94, 2,
+                 2, 0, 'C', CHARSET_LEFT_TO_RIGHT,

                  build_string ("KSC5601"),
                  build_string ("KSC5601 (Korean"),
                  build_string ("KSC5601 Korean Hangul and Hanja"),
                  build_string ("KSC5601"),
                  build_string ("KSC5601 (Korean"),
                  build_string ("KSC5601 Korean Hangul and Hanja"),

-                 build_string ("ksc5601"));
+                 build_string ("ksc5601"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_japanese_jisx0212);
   Vcharset_japanese_jisx0212 =
   staticpro (&Vcharset_japanese_jisx0212);
   Vcharset_japanese_jisx0212 =

-    make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'D',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 94, 2,
+                 2, 0, 'D', CHARSET_LEFT_TO_RIGHT,

                  build_string ("JISX0212"),
                  build_string ("JISX0212 (Japanese)"),
                  build_string ("JISX0212 Japanese Supplement"),
                  build_string ("JISX0212"),
                  build_string ("JISX0212 (Japanese)"),
                  build_string ("JISX0212 Japanese Supplement"),

-                 build_string ("jisx0212"));
+                 build_string ("jisx0212"),
+                 Qnil, 0, 0, 0, 33);

 
 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
   staticpro (&Vcharset_chinese_cns11643_1);
   Vcharset_chinese_cns11643_1 =
 
 #define CHINESE_CNS_PLANE_RE(n) "cns11643[.-]\\(.*[.-]\\)?" n "$"
   staticpro (&Vcharset_chinese_cns11643_1);
   Vcharset_chinese_cns11643_1 =

-    make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'G',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 94, 2,
+                 2, 0, 'G', CHARSET_LEFT_TO_RIGHT,

                  build_string ("CNS11643-1"),
                  build_string ("CNS11643-1 (Chinese traditional)"),
                  build_string
                  ("CNS 11643 Plane 1 Chinese traditional"),
                  build_string ("CNS11643-1"),
                  build_string ("CNS11643-1 (Chinese traditional)"),
                  build_string
                  ("CNS 11643 Plane 1 Chinese traditional"),

-                 build_string (CHINESE_CNS_PLANE_RE("1")));
+                 build_string (CHINESE_CNS_PLANE_RE("1")),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_chinese_cns11643_2);
   Vcharset_chinese_cns11643_2 =
   staticpro (&Vcharset_chinese_cns11643_2);
   Vcharset_chinese_cns11643_2 =

-    make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'H',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 94, 2,
+                 2, 0, 'H', CHARSET_LEFT_TO_RIGHT,

                  build_string ("CNS11643-2"),
                  build_string ("CNS11643-2 (Chinese traditional)"),
                  build_string
                  ("CNS 11643 Plane 2 Chinese traditional"),
                  build_string ("CNS11643-2"),
                  build_string ("CNS11643-2 (Chinese traditional)"),
                  build_string
                  ("CNS 11643 Plane 2 Chinese traditional"),

-                 build_string (CHINESE_CNS_PLANE_RE("2")));
+                 build_string (CHINESE_CNS_PLANE_RE("2")),
+                 Qnil, 0, 0, 0, 33);
+#ifdef UTF2000
+  staticpro (&Vcharset_latin_tcvn5712);
+  Vcharset_latin_tcvn5712 =
+    make_charset (LEADING_BYTE_LATIN_TCVN5712, Qlatin_tcvn5712, 96, 1,
+                 1, 1, 'Z', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("TCVN 5712"),
+                 build_string ("TCVN 5712 (VSCII-2)"),
+                 build_string ("Vietnamese TCVN 5712:1983 (VSCII-2)"),
+                 build_string ("tcvn5712\\(\\.1993\\)?-1"),
+                 Qnil, 0, 0, 0, 32);
+  staticpro (&Vcharset_latin_viscii_lower);
+  Vcharset_latin_viscii_lower =
+    make_charset (LEADING_BYTE_LATIN_VISCII_LOWER, Qlatin_viscii_lower, 96, 1,
+                 1, 1, '1', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("VISCII lower"),
+                 build_string ("VISCII lower (Vietnamese)"),
+                 build_string ("VISCII lower (Vietnamese)"),
+                 build_string ("MULEVISCII-LOWER"),
+                 Qnil, 0, 0, 0, 32);
+  staticpro (&Vcharset_latin_viscii_upper);
+  Vcharset_latin_viscii_upper =
+    make_charset (LEADING_BYTE_LATIN_VISCII_UPPER, Qlatin_viscii_upper, 96, 1,
+                 1, 1, '2', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("VISCII upper"),
+                 build_string ("VISCII upper (Vietnamese)"),
+                 build_string ("VISCII upper (Vietnamese)"),
+                 build_string ("MULEVISCII-UPPER"),
+                 Qnil, 0, 0, 0, 32);
+  staticpro (&Vcharset_latin_viscii);
+  Vcharset_latin_viscii =
+    make_charset (LEADING_BYTE_LATIN_VISCII, Qlatin_viscii, 256, 1,
+                 1, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("VISCII"),
+                 build_string ("VISCII 1.1 (Vietnamese)"),
+                 build_string ("VISCII 1.1 (Vietnamese)"),
+                 build_string ("VISCII1\\.1"),
+                 Qnil, 0, 0, 0, 0);
+  staticpro (&Vcharset_chinese_big5);
+  Vcharset_chinese_big5 =
+    make_charset (LEADING_BYTE_CHINESE_BIG5, Qchinese_big5, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Big5"),
+                 build_string ("Big5"),
+                 build_string ("Big5 Chinese traditional"),
+                 build_string ("big5"),
+                 Qnil, 0, 0, 0, 0);
+  staticpro (&Vcharset_chinese_big5_cdp);
+  Vcharset_chinese_big5_cdp =
+    make_charset (LEADING_BYTE_CHINESE_BIG5_CDP, Qchinese_big5_cdp, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Big5-CDP"),
+                 build_string ("Big5 + CDP extension"),
+                 build_string ("Big5 with CDP extension"),
+                 build_string ("big5\\.cdp-0"),
+                 Qnil, 0, 0, 0, 0);
+  staticpro (&Vcharset_japanese_jef_china3);
+  Vcharset_japanese_jef_china3 =
+    make_charset (LEADING_BYTE_JEF_CHINA3, Qjapanese_jef_china3, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("JC3"),
+                 build_string ("JEF + CHINA3"),
+                 build_string ("JEF + CHINA3 private characters"),
+                 build_string ("china3jef-0"),
+                 Qnil, MIN_CHAR_JEF_CHINA3, MAX_CHAR_JEF_CHINA3, 0, 0);
+  staticpro (&Vcharset_ideograph_gt);
+  Vcharset_ideograph_gt =
+    make_charset (LEADING_BYTE_GT, Qideograph_gt, 256, 3,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("GT"),
+                 build_string ("GT"),
+                 build_string ("GT"),
+                 build_string (""),
+                 Qnil, MIN_CHAR_GT, MAX_CHAR_GT, 0, 0);
+#define DEF_GT_PJ(n)                                                   \
+  staticpro (&Vcharset_ideograph_gt_pj_##n);                           \
+  Vcharset_ideograph_gt_pj_##n =                                       \
+    make_charset (LEADING_BYTE_GT_PJ_##n, Qideograph_gt_pj_##n, 94, 2, \
+                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,                       \
+                 build_string ("GT-PJ-"#n),                            \
+                 build_string ("GT (pseudo JIS encoding) part "#n),    \
+                 build_string ("GT 2000 (pseudo JIS encoding) part "#n), \
+                 build_string                                          \
+                 ("\\(GTpj-"#n "\\|jisx0208\\.GT-"#n "\\)$"),  \
+                 Qnil, 0, 0, 0, 33);
+  DEF_GT_PJ (1);
+  DEF_GT_PJ (2);
+  DEF_GT_PJ (3);
+  DEF_GT_PJ (4);
+  DEF_GT_PJ (5);
+  DEF_GT_PJ (6);
+  DEF_GT_PJ (7);
+  DEF_GT_PJ (8);
+  DEF_GT_PJ (9);
+  DEF_GT_PJ (10);
+  DEF_GT_PJ (11);
+
+  staticpro (&Vcharset_ideograph_daikanwa);
+  Vcharset_ideograph_daikanwa =
+    make_charset (LEADING_BYTE_DAIKANWA, Qideograph_daikanwa, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Daikanwa"),
+                 build_string ("Morohashi's Daikanwa"),
+                 build_string ("Daikanwa dictionary by MOROHASHI Tetsuji"),
+                 build_string ("Daikanwa"),
+                 Qnil, MIN_CHAR_DAIKANWA, MAX_CHAR_DAIKANWA, 0, 0);
+  staticpro (&Vcharset_mojikyo);
+  Vcharset_mojikyo =
+    make_charset (LEADING_BYTE_MOJIKYO, Qmojikyo, 256, 3,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Mojikyo"),
+                 build_string ("Mojikyo"),
+                 build_string ("Konjaku-Mojikyo"),
+                 build_string (""),
+                 Qnil, MIN_CHAR_MOJIKYO, MAX_CHAR_MOJIKYO, 0, 0);
+  staticpro (&Vcharset_mojikyo_2022_1);
+  Vcharset_mojikyo_2022_1 =
+    make_charset (LEADING_BYTE_MOJIKYO_2022_1, Qmojikyo_2022_1, 94, 3,
+                 2, 2, ':', CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Mojikyo-2022-1"),
+                 build_string ("Mojikyo ISO-2022 Part 1"),
+                 build_string ("Konjaku-Mojikyo for ISO/IEC 2022 Part 1"),
+                 build_string (""),
+                 Qnil, 0, 0, 0, 33);
+
+#define DEF_MOJIKYO_PJ(n)                                                 \
+  staticpro (&Vcharset_mojikyo_pj_##n);                                           \
+  Vcharset_mojikyo_pj_##n =                                               \
+    make_charset (LEADING_BYTE_MOJIKYO_PJ_##n, Qmojikyo_pj_##n, 94, 2,    \
+                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,                          \
+                 build_string ("Mojikyo-PJ-"#n),                          \
+                 build_string ("Mojikyo (pseudo JIS encoding) part "#n), \
+                 build_string                                             \
+                 ("Konjaku-Mojikyo (pseudo JIS encoding) part "#n),       \
+                 build_string                                             \
+                 ("\\(MojikyoPJ-"#n "\\|jisx0208\\.Mojikyo-"#n "\\)$"),   \
+                 Qnil, 0, 0, 0, 33);
+
+  DEF_MOJIKYO_PJ (1);
+  DEF_MOJIKYO_PJ (2);
+  DEF_MOJIKYO_PJ (3);
+  DEF_MOJIKYO_PJ (4);
+  DEF_MOJIKYO_PJ (5);
+  DEF_MOJIKYO_PJ (6);
+  DEF_MOJIKYO_PJ (7);
+  DEF_MOJIKYO_PJ (8);
+  DEF_MOJIKYO_PJ (9);
+  DEF_MOJIKYO_PJ (10);
+  DEF_MOJIKYO_PJ (11);
+  DEF_MOJIKYO_PJ (12);
+  DEF_MOJIKYO_PJ (13);
+  DEF_MOJIKYO_PJ (14);
+  DEF_MOJIKYO_PJ (15);
+  DEF_MOJIKYO_PJ (16);
+  DEF_MOJIKYO_PJ (17);
+  DEF_MOJIKYO_PJ (18);
+  DEF_MOJIKYO_PJ (19);
+  DEF_MOJIKYO_PJ (20);
+  DEF_MOJIKYO_PJ (21);
+
+  staticpro (&Vcharset_ethiopic_ucs);
+  Vcharset_ethiopic_ucs =
+    make_charset (LEADING_BYTE_ETHIOPIC_UCS, Qethiopic_ucs, 256, 2,
+                 2, 2, 0, CHARSET_LEFT_TO_RIGHT,
+                 build_string ("Ethiopic (UCS)"),
+                 build_string ("Ethiopic (UCS)"),
+                 build_string ("Ethiopic of UCS"),
+                 build_string ("Ethiopic-Unicode"),
+                 Qnil, 0x1200, 0x137F, 0x1200, 0);
+#endif

   staticpro (&Vcharset_chinese_big5_1);
   Vcharset_chinese_big5_1 =
   staticpro (&Vcharset_chinese_big5_1);
   Vcharset_chinese_big5_1 =

-    make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 3,
-                 CHARSET_TYPE_94X94, 2, 0, '0',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 94, 2,
+                 2, 0, '0', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Big5"),
                  build_string ("Big5 (Level-1)"),
                  build_string
                  ("Big5 Level-1 Chinese traditional"),
                  build_string ("Big5"),
                  build_string ("Big5 (Level-1)"),
                  build_string
                  ("Big5 Level-1 Chinese traditional"),

-                 build_string ("big5"));
+                 build_string ("big5"),
+                 Qnil, 0, 0, 0, 33);

   staticpro (&Vcharset_chinese_big5_2);
   Vcharset_chinese_big5_2 =
   staticpro (&Vcharset_chinese_big5_2);
   Vcharset_chinese_big5_2 =

-    make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 3,
-                 CHARSET_TYPE_94X94, 2, 0, '1',
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 94, 2,
+                 2, 0, '1', CHARSET_LEFT_TO_RIGHT,

                  build_string ("Big5"),
                  build_string ("Big5 (Level-2)"),
                  build_string
                  ("Big5 Level-2 Chinese traditional"),
                  build_string ("Big5"),
                  build_string ("Big5 (Level-2)"),
                  build_string
                  ("Big5 Level-2 Chinese traditional"),

-                 build_string ("big5"));
-
+                 build_string ("big5"),
+                 Qnil, 0, 0, 0, 33);

 
 #ifdef ENABLE_COMPOSITE_CHARS
   /* #### For simplicity, we put composite chars into a 96x96 charset.
 
 #ifdef ENABLE_COMPOSITE_CHARS
   /* #### For simplicity, we put composite chars into a 96x96 charset.

@@ -1582,9 +2927,8 @@ complex_vars_of_mule_charset (void)
      room, esp. as we don't yet recycle numbers. */
   staticpro (&Vcharset_composite);
   Vcharset_composite =
      room, esp. as we don't yet recycle numbers. */
   staticpro (&Vcharset_composite);
   Vcharset_composite =

-    make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 3,
-                 CHARSET_TYPE_96X96, 2, 0, 0,
-                 CHARSET_LEFT_TO_RIGHT,
+    make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 96, 2,
+                 2, 0, 0, CHARSET_LEFT_TO_RIGHT,

                  build_string ("Composite"),
                  build_string ("Composite characters"),
                  build_string ("Composite characters"),
                  build_string ("Composite"),
                  build_string ("Composite characters"),
                  build_string ("Composite characters"),