Sync up with r21-2-19-tomo-6.

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

diff --git a/src/mule-charset.c b/src/mule-charset.c
index eb86610..7959a90 100644 (file)
--- a/src/mule-charset.c
+++ b/src/mule-charset.c
@@ -19,7 +19,7 @@ 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: Mule 2.3.  Not in FSF. */
+/* Synched up with: FSF 20.3.  Not in FSF. */

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

@@ -32,6 +32,7 @@ Boston, MA 02111-1307, USA.  */
 #include "lstream.h"
 #include "device.h"
 #include "faces.h"
 #include "lstream.h"
 #include "device.h"
 #include "faces.h"

+#include "mule-ccl.h"

 
 /* The various pre-defined charsets. */
 
 
 /* The various pre-defined charsets. */
 

@@ -41,40 +42,45 @@ Lisp_Object Vcharset_latin_iso8859_1;
 Lisp_Object Vcharset_latin_iso8859_2;
 Lisp_Object Vcharset_latin_iso8859_3;
 Lisp_Object Vcharset_latin_iso8859_4;
 Lisp_Object Vcharset_latin_iso8859_2;
 Lisp_Object Vcharset_latin_iso8859_3;
 Lisp_Object Vcharset_latin_iso8859_4;

-Lisp_Object Vcharset_cyrillic_iso8859_5;
-Lisp_Object Vcharset_arabic_iso8859_6;
+Lisp_Object Vcharset_thai_tis620;

 Lisp_Object Vcharset_greek_iso8859_7;
 Lisp_Object Vcharset_greek_iso8859_7;

+Lisp_Object Vcharset_arabic_iso8859_6;

 Lisp_Object Vcharset_hebrew_iso8859_8;
 Lisp_Object Vcharset_hebrew_iso8859_8;

-Lisp_Object Vcharset_latin_iso8859_9;
-Lisp_Object Vcharset_thai_tis620;

 Lisp_Object Vcharset_katakana_jisx0201;
 Lisp_Object Vcharset_latin_jisx0201;
 Lisp_Object Vcharset_katakana_jisx0201;
 Lisp_Object Vcharset_latin_jisx0201;

+Lisp_Object Vcharset_cyrillic_iso8859_5;
+Lisp_Object Vcharset_latin_iso8859_9;

 Lisp_Object Vcharset_japanese_jisx0208_1978;
 Lisp_Object Vcharset_japanese_jisx0208_1978;

+Lisp_Object Vcharset_chinese_gb2312;

 Lisp_Object Vcharset_japanese_jisx0208;
 Lisp_Object Vcharset_japanese_jisx0208;

+Lisp_Object Vcharset_korean_ksc5601;

 Lisp_Object Vcharset_japanese_jisx0212;
 Lisp_Object Vcharset_japanese_jisx0212;

-Lisp_Object Vcharset_chinese_gb2312;
-Lisp_Object Vcharset_chinese_big5_1;
-Lisp_Object Vcharset_chinese_big5_2;

 Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;
 Lisp_Object Vcharset_chinese_cns11643_1;
 Lisp_Object Vcharset_chinese_cns11643_2;

-Lisp_Object Vcharset_korean_ksc5601;
+Lisp_Object Vcharset_chinese_big5_1;
+Lisp_Object Vcharset_chinese_big5_2;
+
+#ifdef ENABLE_COMPOSITE_CHARS

 Lisp_Object Vcharset_composite;
 
 Lisp_Object Vcharset_composite;
 

-/* Hashtables for composite chars.  One maps string representing
+/* Hash tables for composite chars.  One maps string representing

    composed chars to their equivalent chars; one goes the
    other way. */
    composed chars to their equivalent chars; one goes the
    other way. */

-Lisp_Object Vcomposite_char_char2string_hashtable;
-Lisp_Object Vcomposite_char_string2char_hashtable;
+Lisp_Object Vcomposite_char_char2string_hash_table;
+Lisp_Object Vcomposite_char_string2char_hash_table;
+
+static int composite_char_row_next;
+static int composite_char_col_next;
+
+#endif /* ENABLE_COMPOSITE_CHARS */

 
 /* Table of charsets indexed by leading byte. */
 
 /* Table of charsets indexed by leading byte. */

-Lisp_Object charset_by_leading_byte[128];
+Lisp_Object charset_by_leading_byte[NUM_LEADING_BYTES];

 
 /* Table of charsets indexed by type/final-byte/direction. */
 Lisp_Object charset_by_attributes[4][128][2];
 
 
 /* Table of charsets indexed by type/final-byte/direction. */
 Lisp_Object charset_by_attributes[4][128][2];
 

-static int composite_char_row_next;
-static int composite_char_col_next;
-
+#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.
 

@@ -94,12 +100,21 @@ 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
+
+Lisp_Object Vutf_2000_version;
+
+int leading_code_private_11;

 
 Lisp_Object Qcharsetp;
 
 
 Lisp_Object Qcharsetp;
 

@@ -107,36 +122,37 @@ Lisp_Object Qcharsetp;
 Lisp_Object Qregistry, Qfinal, Qgraphic;
 Lisp_Object Qdirection;
 Lisp_Object Qreverse_direction_charset;
 Lisp_Object Qregistry, Qfinal, Qgraphic;
 Lisp_Object Qdirection;
 Lisp_Object Qreverse_direction_charset;

-Lisp_Object Qccl_program;
-
-Lisp_Object Qascii, Qcontrol_1,
+Lisp_Object Qleading_byte;
+Lisp_Object Qshort_name, Qlong_name;

 
 

+Lisp_Object Qascii,
+  Qcontrol_1,

   Qlatin_iso8859_1,
   Qlatin_iso8859_2,
   Qlatin_iso8859_3,
   Qlatin_iso8859_4,
   Qlatin_iso8859_1,
   Qlatin_iso8859_2,
   Qlatin_iso8859_3,
   Qlatin_iso8859_4,

-  Qcyrillic_iso8859_5,
-  Qarabic_iso8859_6,
+  Qthai_tis620,

   Qgreek_iso8859_7,
   Qgreek_iso8859_7,

+  Qarabic_iso8859_6,

   Qhebrew_iso8859_8,
   Qhebrew_iso8859_8,

+  Qkatakana_jisx0201,
+  Qlatin_jisx0201,
+  Qcyrillic_iso8859_5,

   Qlatin_iso8859_9,
   Qlatin_iso8859_9,

-
-  Qthai_tis620,
-
-  Qkatakana_jisx0201, Qlatin_jisx0201,

   Qjapanese_jisx0208_1978,
   Qjapanese_jisx0208_1978,

+  Qchinese_gb2312,

   Qjapanese_jisx0208,
   Qjapanese_jisx0208,

+  Qkorean_ksc5601,

   Qjapanese_jisx0212,
   Qjapanese_jisx0212,

-
-  Qchinese_gb2312,
-  Qchinese_big5_1, Qchinese_big5_2,
-  Qchinese_cns11643_1, Qchinese_cns11643_2,
-
-  Qkorean_ksc5601, Qcomposite;
+  Qchinese_cns11643_1,
+  Qchinese_cns11643_2,
+  Qchinese_big5_1,
+  Qchinese_big5_2,
+  Qcomposite;

 
 Lisp_Object Ql2r, Qr2l;
 
 
 Lisp_Object Ql2r, Qr2l;
 

-Lisp_Object Vcharset_hashtable;
+Lisp_Object Vcharset_hash_table;

 
 static Bufbyte next_allocated_1_byte_leading_byte;
 static Bufbyte next_allocated_2_byte_leading_byte;
 
 static Bufbyte next_allocated_1_byte_leading_byte;
 static Bufbyte next_allocated_2_byte_leading_byte;

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

+#ifndef UTF2000

   Bufbyte lb;
   int c1, c2;
   Lisp_Object charset;
   Bufbyte lb;
   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))

@@ -199,7 +258,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);
 }
 

@@ -210,6 +269,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;
 

@@ -226,11 +328,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)
 {

@@ -277,14 +381,16 @@ non_ascii_valid_char_p (Emchar ch)
       if (f2 < 0x20 || f3 < 0x20)
        return 0;
 
       if (f2 < 0x20 || f3 < 0x20)
        return 0;
 

+#ifdef ENABLE_COMPOSITE_CHARS

       if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE)
        {
          if (UNBOUNDP (Fgethash (make_int (ch),
       if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE)
        {
          if (UNBOUNDP (Fgethash (make_int (ch),

-                                 Vcomposite_char_char2string_hashtable,
+                                 Vcomposite_char_char2string_hash_table,

                                  Qunbound)))
            return 0;
          return 1;
        }
                                  Qunbound)))
            return 0;
          return 1;
        }

+#endif /* ENABLE_COMPOSITE_CHARS */

 
       if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F)
        return 1;
 
       if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F)
        return 1;

@@ -299,6 +405,7 @@ non_ascii_valid_char_p (Emchar ch)
       return (XCHARSET_CHARS (charset) == 96);
     }
 }
       return (XCHARSET_CHARS (charset) == 96);
     }
 }

+#endif

 
 \f
 /************************************************************************/
 
 \f
 /************************************************************************/

@@ -317,6 +424,10 @@ non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str)
   switch (REP_BYTES_BY_FIRST_BYTE (*strptr))
     {
       /* Notice fallthrough. */
   switch (REP_BYTES_BY_FIRST_BYTE (*strptr))
     {
       /* Notice fallthrough. */

+#ifdef UTF2000
+    case 6: *++strptr = *ptr++;
+    case 5: *++strptr = *ptr++;
+#endif

     case 4: *++strptr = *ptr++;
     case 3: *++strptr = *ptr++;
     case 2: *++strptr = *ptr;
     case 4: *++strptr = *ptr++;
     case 3: *++strptr = *ptr++;
     case 2: *++strptr = *ptr;

@@ -346,6 +457,16 @@ Lstream_get_emchar_1 (Lstream *stream, int ch)
   switch (REP_BYTES_BY_FIRST_BYTE (ch))
     {
       /* Notice fallthrough. */
   switch (REP_BYTES_BY_FIRST_BYTE (ch))
     {
       /* Notice fallthrough. */

+#ifdef UTF2000
+    case 6:
+      ch = Lstream_getc (stream);
+      assert (ch >= 0);
+      *++strptr = (Bufbyte) ch;
+    case 5:
+      ch = Lstream_getc (stream);
+      assert (ch >= 0);
+      *++strptr = (Bufbyte) ch;
+#endif

     case 4:
       ch = Lstream_getc (stream);
       assert (ch >= 0);
     case 4:
       ch = Lstream_getc (stream);
       assert (ch >= 0);

@@ -391,9 +512,11 @@ mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
   struct Lisp_Charset *cs = XCHARSET (obj);
 
 {
   struct Lisp_Charset *cs = XCHARSET (obj);
 

-  (markobj) (cs->doc_string);
-  (markobj) (cs->registry);
-  (markobj) (cs->ccl_program);
+  markobj (cs->short_name);
+  markobj (cs->long_name);
+  markobj (cs->doc_string);
+  markobj (cs->registry);
+  markobj (cs->ccl_program);

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

@@ -411,6 +534,10 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
   write_c_string ("#<charset ", printcharfun);
   print_internal (CHARSET_NAME (cs), printcharfun, 0);
   write_c_string (" ", printcharfun);
   write_c_string ("#<charset ", printcharfun);
   print_internal (CHARSET_NAME (cs), printcharfun, 0);
   write_c_string (" ", printcharfun);

+  print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1);
+  write_c_string (" ", printcharfun);
+  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" :
   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" :

@@ -427,25 +554,32 @@ print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
   write_c_string (buf, printcharfun);
 }
 
   write_c_string (buf, printcharfun);
 }
 

+static const struct lrecord_description charset_description[] = {
+  { XD_LISP_OBJECT, offsetof(struct Lisp_Charset, name), 7 },
+  { XD_END }
+};
+

 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,

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

                               struct Lisp_Charset);
 /* Make a new charset. */
 
 static Lisp_Object
                               struct Lisp_Charset);
 /* Make a new charset. */
 
 static Lisp_Object

-make_charset (int id, Lisp_Object name, Bufbyte leading_byte, unsigned char rep_bytes,
+make_charset (int id, Lisp_Object name, unsigned char rep_bytes,

              unsigned char type, unsigned char columns, unsigned char graphic,
              unsigned char type, unsigned char columns, unsigned char graphic,

-             Bufbyte final, unsigned char direction, Lisp_Object doc,
+             Bufbyte final, unsigned char direction,  Lisp_Object short_name,
+             Lisp_Object long_name, Lisp_Object doc,

              Lisp_Object reg)
 {
   Lisp_Object obj;
   struct Lisp_Charset *cs =
              Lisp_Object reg)
 {
   Lisp_Object obj;
   struct Lisp_Charset *cs =

-    alloc_lcrecord_type (struct Lisp_Charset, lrecord_charset);
+    alloc_lcrecord_type (struct Lisp_Charset, &lrecord_charset);

   XSETCHARSET (obj, cs);
 
   CHARSET_ID           (cs) = id;
   CHARSET_NAME         (cs) = name;
   XSETCHARSET (obj, cs);
 
   CHARSET_ID           (cs) = id;
   CHARSET_NAME         (cs) = name;

-  CHARSET_LEADING_BYTE (cs) = leading_byte;
+  CHARSET_SHORT_NAME   (cs) = short_name;
+  CHARSET_LONG_NAME    (cs) = long_name;

   CHARSET_REP_BYTES    (cs) = rep_bytes;
   CHARSET_DIRECTION    (cs) = direction;
   CHARSET_TYPE         (cs) = type;
   CHARSET_REP_BYTES    (cs) = rep_bytes;
   CHARSET_DIRECTION    (cs) = direction;
   CHARSET_TYPE         (cs) = type;

@@ -461,7 +595,7 @@ make_charset (int id, Lisp_Object name, Bufbyte leading_byte, unsigned char rep_
                                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;
                                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;

-    
+

   if (final)
     {
       /* some charsets do not have final characters.  This includes
   if (final)
     {
       /* some charsets do not have final characters.  This includes

@@ -471,16 +605,18 @@ make_charset (int id, Lisp_Object name, Bufbyte leading_byte, unsigned char rep_
       charset_by_attributes[type][final][direction] = obj;
     }
 
       charset_by_attributes[type][final][direction] = obj;
     }
 

-  assert (NILP (charset_by_leading_byte[leading_byte - 128]));
-  charset_by_leading_byte[leading_byte - 128] = obj;
-  if (leading_byte < 0xA0)
+  assert (NILP (charset_by_leading_byte[id - MIN_LEADING_BYTE]));
+  charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj;
+#ifndef UTF2000
+  if (id < 0xA0)

     /* official leading byte */
     /* official leading byte */

-    rep_bytes_by_first_byte[leading_byte] = rep_bytes;
+    rep_bytes_by_first_byte[id] = rep_bytes;
+#endif

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

-    Fputhash (name, obj, Vcharset_hashtable);
+    Fputhash (name, obj, Vcharset_hash_table);

   return obj;
 }
 
   return obj;
 }
 

@@ -537,7 +673,7 @@ nil is returned.  Otherwise the associated charset object is returned.
     return charset_or_name;
 
   CHECK_SYMBOL (charset_or_name);
     return charset_or_name;
 
   CHECK_SYMBOL (charset_or_name);

-  return Fgethash (charset_or_name, Vcharset_hashtable, Qnil);
+  return Fgethash (charset_or_name, Vcharset_hash_table, Qnil);

 }
 
 DEFUN ("get-charset", Fget_charset, 1, 1, 0, /*
 }
 
 DEFUN ("get-charset", Fget_charset, 1, 1, 0, /*

@@ -563,19 +699,15 @@ struct charset_list_closure
 };
 
 static int
 };
 
 static int

-add_charset_to_list_mapper (CONST void *hash_key, void *hash_contents,
+add_charset_to_list_mapper (Lisp_Object key, Lisp_Object value,

                            void *charset_list_closure)
 {
   /* This function can GC */
                            void *charset_list_closure)
 {
   /* This function can GC */

-  Lisp_Object key, contents;
-  Lisp_Object *charset_list;

   struct charset_list_closure *chcl =
     (struct charset_list_closure*) charset_list_closure;
   struct charset_list_closure *chcl =
     (struct charset_list_closure*) charset_list_closure;

-  CVOID_TO_LISP (key, hash_key);
-  VOID_TO_LISP (contents, hash_contents);
-  charset_list = chcl->charset_list;
+  Lisp_Object *charset_list = chcl->charset_list;

 
 

-  *charset_list = Fcons (XCHARSET_NAME (contents), *charset_list);
+  *charset_list = Fcons (XCHARSET_NAME (value), *charset_list);

   return 0;
 }
 
   return 0;
 }
 

@@ -590,7 +722,7 @@ Return a list of the names of all defined charsets.
 
   GCPRO1 (charset_list);
   charset_list_closure.charset_list = &charset_list;
 
   GCPRO1 (charset_list);
   charset_list_closure.charset_list = &charset_list;

-  elisp_maphash (add_charset_to_list_mapper, Vcharset_hashtable,
+  elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table,

                 &charset_list_closure);
   UNGCPRO;
 
                 &charset_list_closure);
   UNGCPRO;
 

@@ -613,6 +745,8 @@ DOC-STRING is a string describing the character set.
 PROPS is a property list, describing the specific nature of the
 character set.  Recognized properties are:
 
 PROPS is a property list, describing the specific nature of the
 character set.  Recognized properties are:
 

+'short-name    Short version of the charset name (ex: Latin-1)
+'long-name     Long version of the charset name (ex: ISO8859-1 (Latin-1))

 'registry      A regular expression matching the font registry field for
                this character set.
 'dimension     Number of octets used to index a character in this charset.
 'registry      A regular expression matching the font registry field for
                this character set.
 'dimension     Number of octets used to index a character in this charset.

@@ -652,13 +786,14 @@ character set.  Recognized properties are:
 */
        (name, doc_string, props))
 {
 */
        (name, doc_string, props))
 {

-  int lb, dimension = 1, chars = 94, graphic = 0, final = 0, columns = -1;
+  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 rest, keyword, value;
   Lisp_Object ccl_program = Qnil;
   int direction = CHARSET_LEFT_TO_RIGHT;
   int type;
   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;

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

@@ -670,7 +805,19 @@ character set.  Recognized properties are:
 
   EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
     {
 
   EXTERNAL_PROPERTY_LIST_LOOP (rest, keyword, value, props)
     {

-      if (EQ (keyword, Qdimension))
+      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);
        {
          CHECK_INT (value);
          dimension = XINT (value);

@@ -753,7 +900,7 @@ character set.  Recognized properties are:
     error
       ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
 
     error
       ("Character set already defined for this DIMENSION/CHARS/FINAL combo");
 

-  lb = get_unallocated_leading_byte (dimension);
+  id = get_unallocated_leading_byte (dimension);

 
   if (NILP (doc_string))
     doc_string = build_string ("");
 
   if (NILP (doc_string))
     doc_string = build_string ("");

@@ -761,10 +908,16 @@ character set.  Recognized properties are:
   if (NILP (registry))
     registry = build_string ("");
 
   if (NILP (registry))
     registry = build_string ("");
 

+  if (NILP (short_name))
+    XSETSTRING (short_name, XSYMBOL (name)->name);
+
+  if (NILP (long_name))
+    long_name = doc_string;
+

   if (columns == -1)
     columns = dimension;
   if (columns == -1)
     columns = dimension;

-  charset = make_charset (-1, name, lb, dimension + 2, type, columns, graphic,
-                         final, direction, doc_string, registry);
+  charset = make_charset (id, name, dimension + 2, type, columns, graphic,
+                         final, direction, short_name, long_name, doc_string, registry);

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

@@ -778,9 +931,9 @@ 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 lb, dimension, columns, graphic, final;
+  int id, dimension, columns, graphic, final;

   int direction, type;
   int direction, type;

-  Lisp_Object registry, doc_string;
+  Lisp_Object registry, doc_string, short_name, long_name;

   struct Lisp_Charset *cs;
 
   charset = Fget_charset (charset);
   struct Lisp_Charset *cs;
 
   charset = Fget_charset (charset);

@@ -797,7 +950,7 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   type      = CHARSET_TYPE      (cs);
   columns   = CHARSET_COLUMNS   (cs);
   dimension = CHARSET_DIMENSION (cs);
   type      = CHARSET_TYPE      (cs);
   columns   = CHARSET_COLUMNS   (cs);
   dimension = CHARSET_DIMENSION (cs);

-  lb = get_unallocated_leading_byte (dimension);
+  id = get_unallocated_leading_byte (dimension);

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

@@ -805,10 +958,13 @@ NEW-NAME is the name of the new charset.  Return the new charset.
   if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT)
     direction = CHARSET_LEFT_TO_RIGHT;
   doc_string = CHARSET_DOC_STRING (cs);
   if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT)
     direction = CHARSET_LEFT_TO_RIGHT;
   doc_string = CHARSET_DOC_STRING (cs);

+  short_name = CHARSET_SHORT_NAME (cs);
+  long_name = CHARSET_LONG_NAME (cs);

   registry = CHARSET_REGISTRY (cs);
 
   registry = CHARSET_REGISTRY (cs);
 

-  new_charset = make_charset (-1, new_name, lb, dimension + 2, type, columns,
-                             graphic, final, direction, doc_string, registry);
+  new_charset = make_charset (id, new_name, dimension + 2, type, columns,
+                             graphic, final, direction, short_name, long_name,
+                             doc_string, registry);

 
   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;

@@ -888,8 +1044,24 @@ will be returned if character sets exist for both directions).
   return obj;
 }
 
   return obj;
 }
 

-DEFUN ("charset-doc-string", Fcharset_doc_string, 1, 1, 0, /*
-Return doc string of CHARSET.
+DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /*
+Return short name of CHARSET.
+*/
+       (charset))
+{
+  return XCHARSET_SHORT_NAME (Fget_charset (charset));
+}
+
+DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /*
+Return long name of CHARSET.
+*/
+       (charset))
+{
+  return XCHARSET_LONG_NAME (Fget_charset (charset));
+}
+
+DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /*
+Return description of CHARSET.

 */
        (charset))
 {
 */
        (charset))
 {

@@ -918,6 +1090,8 @@ Recognized properties are those listed in `make-charset', as well as
 
   CHECK_SYMBOL (prop);
   if (EQ (prop, Qname))        return CHARSET_NAME (cs);
 
   CHECK_SYMBOL (prop);
   if (EQ (prop, Qname))        return CHARSET_NAME (cs);

+  if (EQ (prop, Qshort_name))  return CHARSET_SHORT_NAME (cs);
+  if (EQ (prop, Qlong_name))   return CHARSET_LONG_NAME (cs);

   if (EQ (prop, Qdoc_string))  return CHARSET_DOC_STRING (cs);
   if (EQ (prop, Qdimension))   return make_int (CHARSET_DIMENSION (cs));
   if (EQ (prop, Qcolumns))     return make_int (CHARSET_COLUMNS (cs));
   if (EQ (prop, Qdoc_string))  return CHARSET_DOC_STRING (cs);
   if (EQ (prop, Qdimension))   return make_int (CHARSET_DIMENSION (cs));
   if (EQ (prop, Qcolumns))     return make_int (CHARSET_COLUMNS (cs));

@@ -945,7 +1119,7 @@ Return charset identification number of CHARSET.
 */
        (charset))
 {
 */
        (charset))
 {

-  return make_int(XCHARSET_ID (Fget_charset (charset)));
+  return make_int(XCHARSET_LEADING_BYTE (Fget_charset (charset)));

 }
 
 /* #### We need to figure out which properties we really want to
 }
 
 /* #### We need to figure out which properties we really want to

@@ -966,13 +1140,13 @@ static void
 invalidate_charset_font_caches (Lisp_Object charset)
 {
   /* Invalidate font cache entries for charset on all devices. */
 invalidate_charset_font_caches (Lisp_Object charset)
 {
   /* Invalidate font cache entries for charset on all devices. */

-  Lisp_Object devcons, concons, hashtab;
+  Lisp_Object devcons, concons, hash_table;

   DEVICE_LOOP_NO_BREAK (devcons, concons)
     {
       struct device *d = XDEVICE (XCAR (devcons));
   DEVICE_LOOP_NO_BREAK (devcons, concons)
     {
       struct device *d = XDEVICE (XCAR (devcons));

-      hashtab = Fgethash (charset, d->charset_font_cache, Qunbound);
-      if (!UNBOUNDP (hashtab))
-        Fclrhash (hashtab);
+      hash_table = Fgethash (charset, d->charset_font_cache, Qunbound);
+      if (!UNBOUNDP (hash_table))
+        Fclrhash (hash_table);

     }
 }
 
     }
 }
 

@@ -996,7 +1170,10 @@ Set the 'registry property of CHARSET to REGISTRY.
 /************************************************************************/
 
 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*
 /************************************************************************/
 
 DEFUN ("make-char", Fmake_char, 2, 3, 0, /*

-Make a multi-byte character from CHARSET and octets ARG1 and ARG2.
+Make a character from CHARSET and octets ARG1 and ARG2.
+ARG2 is required only for characters from two-dimensional charsets.
+For example, (make-char 'latin-iso8859-2 185) will return the Latin 2
+character s with caron.

 */
        (charset, arg1, arg2))
 {
 */
        (charset, arg1, arg2))
 {

@@ -1013,7 +1190,11 @@ Make a multi-byte character from CHARSET and octets ARG1 and ARG2.
   else /* CHARSET_CHARS (cs) == 96) */      lowlim = 32, highlim = 127;
 
   CHECK_INT (arg1);
   else /* CHARSET_CHARS (cs) == 96) */      lowlim = 32, highlim = 127;
 
   CHECK_INT (arg1);

-  a1 = XINT (arg1);
+  /* It is useful (and safe, according to Olivier Galibert) to strip
+     the 8th bit off ARG1 and ARG2 becaue it allows programmers to
+     write (make-char 'latin-iso8859-2 CODE) where code is the actual
+     Latin 2 code of the character.  */
+  a1 = XINT (arg1) & 0x7f;

   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));
 

@@ -1026,7 +1207,7 @@ Make a multi-byte character from CHARSET and octets ARG1 and ARG2.
     }
 
   CHECK_INT (arg2);
     }
 
   CHECK_INT (arg2);

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

   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));
 

@@ -1044,30 +1225,37 @@ Return the character set of char CH.
                        (CHAR_LEADING_BYTE (XCHAR (ch))));
 }
 
                        (CHAR_LEADING_BYTE (XCHAR (ch))));
 }
 

-DEFUN ("char-octet", Fchar_octet, 1, 2, 0, /*
-Return the octet numbered N (should be 0 or 1) of char CH.
-N defaults to 0 if omitted.
+DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
+Return list of charset and one or two position-codes of CHAR.

 */
 */

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

 {
 {

-  Lisp_Object charset;
-  int c1, c2, int_n;
+  /* This function can GC */
+  struct gcpro gcpro1, gcpro2;
+  Lisp_Object charset = Qnil;
+  Lisp_Object rc = Qnil;
+  int c1, c2;

 
 

-  CHECK_CHAR_COERCE_INT (ch);
-  if (NILP (n))
-    int_n = 0;
+  GCPRO2 (charset, rc);
+  CHECK_CHAR_COERCE_INT (character);
+
+  BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
+
+  if (XCHARSET_DIMENSION (Fget_charset (charset)) == 2)
+    {
+      rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2));
+    }

   else
     {
   else
     {

-      CHECK_INT (n);
-      int_n = XINT (n);
-      if (int_n != 0 && int_n != 1)
-       signal_simple_error ("Octet number must be 0 or 1", n);
+      rc = list2 (XCHARSET_NAME (charset), make_int (c1));

     }
     }

-  BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
-  return make_int (int_n == 0 ? c1 : c2);
+  UNGCPRO;
+
+  return rc;

 }
 
 \f
 }
 
 \f

+#ifdef ENABLE_COMPOSITE_CHARS

 /************************************************************************/
 /*                     composite character functions                    */
 /************************************************************************/
 /************************************************************************/
 /*                     composite character functions                    */
 /************************************************************************/

@@ -1077,7 +1265,7 @@ lookup_composite_char (Bufbyte *str, int len)
 {
   Lisp_Object lispstr = make_string (str, len);
   Lisp_Object ch = Fgethash (lispstr,
 {
   Lisp_Object lispstr = make_string (str, len);
   Lisp_Object ch = Fgethash (lispstr,

-                            Vcomposite_char_string2char_hashtable,
+                            Vcomposite_char_string2char_hash_table,

                             Qunbound);
   Emchar emch;
 
                             Qunbound);
   Emchar emch;
 

@@ -1088,9 +1276,9 @@ lookup_composite_char (Bufbyte *str, int len)
       emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
                        composite_char_col_next);
       Fputhash (make_char (emch), lispstr,
       emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
                        composite_char_col_next);
       Fputhash (make_char (emch), lispstr,

-               Vcomposite_char_char2string_hashtable);
+               Vcomposite_char_char2string_hash_table);

       Fputhash (lispstr, make_char (emch),
       Fputhash (lispstr, make_char (emch),

-               Vcomposite_char_string2char_hashtable);
+               Vcomposite_char_string2char_hash_table);

       composite_char_col_next++;
       if (composite_char_col_next >= 128)
        {
       composite_char_col_next++;
       if (composite_char_col_next >= 128)
        {

@@ -1107,13 +1295,13 @@ Lisp_Object
 composite_char_string (Emchar ch)
 {
   Lisp_Object str = Fgethash (make_char (ch),
 composite_char_string (Emchar ch)
 {
   Lisp_Object str = Fgethash (make_char (ch),

-                             Vcomposite_char_char2string_hashtable,
+                             Vcomposite_char_char2string_hash_table,

                              Qunbound);
   assert (!UNBOUNDP (str));
   return str;
 }
 
                              Qunbound);
   assert (!UNBOUNDP (str));
   return str;
 }
 

-DEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*
+xxDEFUN ("make-composite-char", Fmake_composite_char, 1, 1, 0, /*

 Convert a string into a single composite character.
 The character is the result of overstriking all the characters in
 the string.
 Convert a string into a single composite character.
 The character is the result of overstriking all the characters in
 the string.

@@ -1125,7 +1313,7 @@ the string.
                                           XSTRING_LENGTH (string)));
 }
 
                                           XSTRING_LENGTH (string)));
 }
 

-DEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*
+xxDEFUN ("composite-char-string", Fcomposite_char_string, 1, 1, 0, /*

 Return a string of the characters comprising a composite character.
 */
        (ch))
 Return a string of the characters comprising a composite character.
 */
        (ch))

@@ -1138,6 +1326,7 @@ Return a string of the characters comprising a composite character.
     signal_simple_error ("Must be composite char", ch);
   return composite_char_string (emch);
 }
     signal_simple_error ("Must be composite char", ch);
   return composite_char_string (emch);
 }

+#endif /* ENABLE_COMPOSITE_CHARS */

 
 \f
 /************************************************************************/
 
 \f
 /************************************************************************/

@@ -1156,7 +1345,9 @@ syms_of_mule_charset (void)
   DEFSUBR (Fmake_reverse_direction_charset);
   /*  DEFSUBR (Freverse_direction_charset); */
   DEFSUBR (Fcharset_from_attributes);
   DEFSUBR (Fmake_reverse_direction_charset);
   /*  DEFSUBR (Freverse_direction_charset); */
   DEFSUBR (Fcharset_from_attributes);

-  DEFSUBR (Fcharset_doc_string);
+  DEFSUBR (Fcharset_short_name);
+  DEFSUBR (Fcharset_long_name);
+  DEFSUBR (Fcharset_description);

   DEFSUBR (Fcharset_dimension);
   DEFSUBR (Fcharset_property);
   DEFSUBR (Fcharset_id);
   DEFSUBR (Fcharset_dimension);
   DEFSUBR (Fcharset_property);
   DEFSUBR (Fcharset_id);

@@ -1165,10 +1356,12 @@ syms_of_mule_charset (void)
 
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
 
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);

-  DEFSUBR (Fchar_octet);
+  DEFSUBR (Fsplit_char);

 
 

+#ifdef ENABLE_COMPOSITE_CHARS

   DEFSUBR (Fmake_composite_char);
   DEFSUBR (Fcomposite_char_string);
   DEFSUBR (Fmake_composite_char);
   DEFSUBR (Fcomposite_char_string);

+#endif

 
   defsymbol (&Qcharsetp, "charsetp");
   defsymbol (&Qregistry, "registry");
 
   defsymbol (&Qcharsetp, "charsetp");
   defsymbol (&Qregistry, "registry");

@@ -1176,12 +1369,13 @@ syms_of_mule_charset (void)
   defsymbol (&Qgraphic, "graphic");
   defsymbol (&Qdirection, "direction");
   defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
   defsymbol (&Qgraphic, "graphic");
   defsymbol (&Qdirection, "direction");
   defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");

-  defsymbol (&Qccl_program, "ccl-program");
+  defsymbol (&Qshort_name, "short-name");
+  defsymbol (&Qlong_name, "long-name");

 
   defsymbol (&Ql2r, "l2r");
   defsymbol (&Qr2l, "r2l");
 
 
   defsymbol (&Ql2r, "l2r");
   defsymbol (&Qr2l, "r2l");
 

-  /* Charsets, compatible with Emacs/Mule 19.33-delta
+  /* Charsets, compatible with FSF 20.3

      Naming convention is Script-Charset[-Edition] */
   defsymbol (&Qascii,                  "ascii");
   defsymbol (&Qcontrol_1,              "control-1");
      Naming convention is Script-Charset[-Edition] */
   defsymbol (&Qascii,                  "ascii");
   defsymbol (&Qcontrol_1,              "control-1");

@@ -1189,27 +1383,32 @@ syms_of_mule_charset (void)
   defsymbol (&Qlatin_iso8859_2,                "latin-iso8859-2");
   defsymbol (&Qlatin_iso8859_3,                "latin-iso8859-3");
   defsymbol (&Qlatin_iso8859_4,                "latin-iso8859-4");
   defsymbol (&Qlatin_iso8859_2,                "latin-iso8859-2");
   defsymbol (&Qlatin_iso8859_3,                "latin-iso8859-3");
   defsymbol (&Qlatin_iso8859_4,                "latin-iso8859-4");

-  defsymbol (&Qcyrillic_iso8859_5,     "cyrillic-iso8859-5");
-  defsymbol (&Qarabic_iso8859_6,       "arabic-iso8859-6");
+  defsymbol (&Qthai_tis620,            "thai-tis620");

   defsymbol (&Qgreek_iso8859_7,                "greek-iso8859-7");
   defsymbol (&Qgreek_iso8859_7,                "greek-iso8859-7");

+  defsymbol (&Qarabic_iso8859_6,       "arabic-iso8859-6");

   defsymbol (&Qhebrew_iso8859_8,       "hebrew-iso8859-8");
   defsymbol (&Qhebrew_iso8859_8,       "hebrew-iso8859-8");

-  defsymbol (&Qlatin_iso8859_9,                "latin-iso8859-9");
-  defsymbol (&Qthai_tis620,            "thai-tis620");
-

   defsymbol (&Qkatakana_jisx0201,      "katakana-jisx0201");
   defsymbol (&Qlatin_jisx0201,         "latin-jisx0201");
   defsymbol (&Qkatakana_jisx0201,      "katakana-jisx0201");
   defsymbol (&Qlatin_jisx0201,         "latin-jisx0201");

+  defsymbol (&Qcyrillic_iso8859_5,     "cyrillic-iso8859-5");
+  defsymbol (&Qlatin_iso8859_9,                "latin-iso8859-9");

   defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");
   defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978");

+  defsymbol (&Qchinese_gb2312,         "chinese-gb2312");

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

+  defsymbol (&Qkorean_ksc5601,         "korean-ksc5601");

   defsymbol (&Qjapanese_jisx0212,      "japanese-jisx0212");
   defsymbol (&Qjapanese_jisx0212,      "japanese-jisx0212");

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

   defsymbol (&Qchinese_cns11643_1,     "chinese-cns11643-1");
   defsymbol (&Qchinese_cns11643_2,     "chinese-cns11643-2");
   defsymbol (&Qchinese_cns11643_1,     "chinese-cns11643-1");
   defsymbol (&Qchinese_cns11643_2,     "chinese-cns11643-2");

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

 
 

-  defsymbol (&Qkorean_ksc5601,         "korean-ksc5601");

   defsymbol (&Qcomposite,              "composite");
   defsymbol (&Qcomposite,              "composite");

+
+#ifdef UTF2000
+  Vutf_2000_version = build_string("0.4 (Shin-Imamiya)");
+  DEFVAR_LISP ("utf-2000-version", &Vutf_2000_version /*
+Version number of UTF-2000.
+*/ );
+#endif

 }
 
 void
 }
 
 void

@@ -1229,192 +1428,239 @@ vars_of_mule_charset (void)
 
   next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
   next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
 
   next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
   next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;

+
+  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;

 }
 
 void
 complex_vars_of_mule_charset (void)
 {
 }
 
 void
 complex_vars_of_mule_charset (void)
 {

-  staticpro (&Vcharset_hashtable);
-  Vcharset_hashtable = make_lisp_hashtable (50, HASHTABLE_NONWEAK,
-                                           HASHTABLE_EQ);
+  staticpro (&Vcharset_hash_table);
+  Vcharset_hash_table =
+    make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);

 
   /* Predefined character sets.  We store them into variables for
      ease of access. */
 
   Vcharset_ascii =
 
   /* Predefined character sets.  We store them into variables for
      ease of access. */
 
   Vcharset_ascii =

-    make_charset (0, Qascii, LEADING_BYTE_ASCII, 1,
+    make_charset (LEADING_BYTE_ASCII, Qascii, 1,

                  CHARSET_TYPE_94, 1, 0, 'B',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94, 1, 0, 'B',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ASCII (ISO 646 IRV)"),
-                 build_string ("iso8859-1"));
+                 build_string ("ASCII"),
+                 build_string ("ASCII)"),
+                 build_string ("ASCII (ISO646 IRV)"),
+                 build_string ("\\(iso8859-[0-9]*\\|-ascii\\)"));

   Vcharset_control_1 =
   Vcharset_control_1 =

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

                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("C1"),

                  build_string ("Control characters"),
                  build_string ("Control characters"),

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

                  build_string (""));
   Vcharset_latin_iso8859_1 =
                  build_string (""));
   Vcharset_latin_iso8859_1 =

-    make_charset (129, Qlatin_iso8859_1, LEADING_BYTE_LATIN_ISO8859_1, 2,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 2,

                  CHARSET_TYPE_96, 1, 1, 'A',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96, 1, 1, 'A',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-1 (Latin-1)"),
+                 build_string ("Latin-1"),
+                 build_string ("ISO8859-1 (Latin-1)"),
+                 build_string ("ISO8859-1 (Latin-1)"),

                  build_string ("iso8859-1"));
   Vcharset_latin_iso8859_2 =
                  build_string ("iso8859-1"));
   Vcharset_latin_iso8859_2 =

-    make_charset (130, Qlatin_iso8859_2, LEADING_BYTE_LATIN_ISO8859_2, 2,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 2,

                  CHARSET_TYPE_96, 1, 1, 'B',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96, 1, 1, 'B',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-2 (Latin-2)"),
+                 build_string ("Latin-2"),
+                 build_string ("ISO8859-2 (Latin-2)"),
+                 build_string ("ISO8859-2 (Latin-2)"),

                  build_string ("iso8859-2"));
   Vcharset_latin_iso8859_3 =
                  build_string ("iso8859-2"));
   Vcharset_latin_iso8859_3 =

-    make_charset (131, Qlatin_iso8859_3, LEADING_BYTE_LATIN_ISO8859_3, 2,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 2,

                  CHARSET_TYPE_96, 1, 1, 'C',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96, 1, 1, 'C',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-3 (Latin-3)"),
+                 build_string ("Latin-3"),
+                 build_string ("ISO8859-3 (Latin-3)"),
+                 build_string ("ISO8859-3 (Latin-3)"),

                  build_string ("iso8859-3"));
   Vcharset_latin_iso8859_4 =
                  build_string ("iso8859-3"));
   Vcharset_latin_iso8859_4 =

-    make_charset (132, Qlatin_iso8859_4, LEADING_BYTE_LATIN_ISO8859_4, 2,
+    make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 2,

                  CHARSET_TYPE_96, 1, 1, 'D',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96, 1, 1, 'D',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-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"));

-  Vcharset_cyrillic_iso8859_5 =
-    make_charset (140, Qcyrillic_iso8859_5, LEADING_BYTE_CYRILLIC_ISO8859_5, 2,
-                 CHARSET_TYPE_96, 1, 1, 'L',
+  Vcharset_thai_tis620 =
+    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2,
+                 CHARSET_TYPE_96, 1, 1, 'T',

                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-5 (Cyrillic)"),
-                 build_string ("iso8859-5"));
-  Vcharset_arabic_iso8859_6 =
-    make_charset (135, Qarabic_iso8859_6, LEADING_BYTE_ARABIC_ISO8859_6, 2,
-                 CHARSET_TYPE_96, 1, 1, 'G',
-                 CHARSET_RIGHT_TO_LEFT,
-                 build_string ("ISO 8859-6 (Arabic)"),
-                 build_string ("iso8859-6"));
+                 build_string ("TIS620"),
+                 build_string ("TIS620 (Thai)"),
+                 build_string ("TIS620.2529 (Thai)"),
+                 build_string ("tis620"));

   Vcharset_greek_iso8859_7 =
   Vcharset_greek_iso8859_7 =

-    make_charset (134, Qgreek_iso8859_7, LEADING_BYTE_GREEK_ISO8859_7, 2,
+    make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 2,

                  CHARSET_TYPE_96, 1, 1, 'F',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96, 1, 1, 'F',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("ISO 8859-7 (Greek)"),
+                 build_string ("ISO8859-7"),
+                 build_string ("ISO8859-7 (Greek)"),
+                 build_string ("ISO8859-7 (Greek)"),

                  build_string ("iso8859-7"));
                  build_string ("iso8859-7"));

+  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,
+                 build_string ("ISO8859-6"),
+                 build_string ("ISO8859-6 (Arabic)"),
+                 build_string ("ISO8859-6 (Arabic)"),
+                 build_string ("iso8859-6"));

   Vcharset_hebrew_iso8859_8 =
   Vcharset_hebrew_iso8859_8 =

-    make_charset (136, Qhebrew_iso8859_8, LEADING_BYTE_HEBREW_ISO8859_8, 2,
+    make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 2,

                  CHARSET_TYPE_96, 1, 1, 'H',
                  CHARSET_RIGHT_TO_LEFT,
                  CHARSET_TYPE_96, 1, 1, 'H',
                  CHARSET_RIGHT_TO_LEFT,

-                 build_string ("ISO 8859-8 (Hebrew)"),
+                 build_string ("ISO8859-8"),
+                 build_string ("ISO8859-8 (Hebrew)"),
+                 build_string ("ISO8859-8 (Hebrew)"),

                  build_string ("iso8859-8"));
                  build_string ("iso8859-8"));

-  Vcharset_latin_iso8859_9 =
-    make_charset (141, Qlatin_iso8859_9, LEADING_BYTE_LATIN_ISO8859_9, 2,
-                 CHARSET_TYPE_96, 1, 1, 'M',
-                 CHARSET_LEFT_TO_RIGHT,
-                 build_string ("ISO 8859-9 (Latin-5)"),
-                 build_string ("iso8859-9"));
-  Vcharset_thai_tis620 =
-    make_charset (133, Qthai_tis620, LEADING_BYTE_THAI_TIS620, 2,
-                 CHARSET_TYPE_96, 1, 1, 'T',
-                 CHARSET_LEFT_TO_RIGHT,
-                 build_string ("TIS 620.2529 (Thai)"),
-                 build_string ("tis620"));
-
-  /* Japanese */

   Vcharset_katakana_jisx0201 =
   Vcharset_katakana_jisx0201 =

-    make_charset (137, Qkatakana_jisx0201,
-                 LEADING_BYTE_KATAKANA_JISX0201, 2,
+    make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 2,

                  CHARSET_TYPE_94, 1, 1, 'I',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94, 1, 1, 'I',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("JIS X0201-Katakana"),
+                 build_string ("JISX0201 Kana"),
+                 build_string ("JISX0201.1976 (Japanese Kana)"),
+                 build_string ("JISX0201.1976 Japanese Kana"),

                  build_string ("jisx0201.1976"));
   Vcharset_latin_jisx0201 =
                  build_string ("jisx0201.1976"));
   Vcharset_latin_jisx0201 =

-    make_charset (138, Qlatin_jisx0201,
-                 LEADING_BYTE_LATIN_JISX0201, 2,
+    make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2,

                  CHARSET_TYPE_94, 1, 0, 'J',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94, 1, 0, 'J',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("JIS X0201-Latin"),
+                 build_string ("JISX0201 Roman"),
+                 build_string ("JISX0201.1976 (Japanese Roman)"),
+                 build_string ("JISX0201.1976 Japanese Roman"),

                  build_string ("jisx0201.1976"));
                  build_string ("jisx0201.1976"));

+  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,
+                 build_string ("ISO8859-5"),
+                 build_string ("ISO8859-5 (Cyrillic)"),
+                 build_string ("ISO8859-5 (Cyrillic)"),
+                 build_string ("iso8859-5"));
+  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,
+                 build_string ("Latin-5"),
+                 build_string ("ISO8859-9 (Latin-5)"),
+                 build_string ("ISO8859-9 (Latin-5)"),
+                 build_string ("iso8859-9"));

   Vcharset_japanese_jisx0208_1978 =
   Vcharset_japanese_jisx0208_1978 =

-    make_charset (144, Qjapanese_jisx0208_1978,
-                 LEADING_BYTE_JAPANESE_JISX0208_1978, 3,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, 3,

                  CHARSET_TYPE_94X94, 2, 0, '@',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, '@',
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("JISX0208.1978"),
+                 build_string ("JISX0208.1978 (Japanese)"),

                  build_string
                  build_string

-                 ("JIS X0208-1978 (Japanese Kanji; Old Version)"),
-                 build_string ("\\(jisx0208\\|jisc6226\\).19"));
+                 ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"),
+                 build_string ("\\(jisx0208\\|jisc6226\\)\\.1978"));
+  Vcharset_chinese_gb2312 =
+    make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 3,
+                 CHARSET_TYPE_94X94, 2, 0, 'A',
+                 CHARSET_LEFT_TO_RIGHT,
+                 build_string ("GB2312"),
+                 build_string ("GB2312)"),
+                 build_string ("GB2312 Chinese simplified"),
+                 build_string ("gb2312"));

   Vcharset_japanese_jisx0208 =
   Vcharset_japanese_jisx0208 =

-    make_charset (146, Qjapanese_jisx0208,
-                 LEADING_BYTE_JAPANESE_JISX0208, 3,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3,

                  CHARSET_TYPE_94X94, 2, 0, 'B',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, 'B',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("JIS X0208-1983 (Japanese Kanji)"),
+                 build_string ("JISX0208"),
+                 build_string ("JISX0208.1983/1990 (Japanese)"),
+                 build_string ("JISX0208.1983/1990 Japanese Kanji"),

                  build_string ("jisx0208.19\\(83\\|90\\)"));
                  build_string ("jisx0208.19\\(83\\|90\\)"));

+  Vcharset_korean_ksc5601 =
+    make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 3,
+                 CHARSET_TYPE_94X94, 2, 0, 'C',
+                 CHARSET_LEFT_TO_RIGHT,
+                 build_string ("KSC5601"),
+                 build_string ("KSC5601 (Korean"),
+                 build_string ("KSC5601 Korean Hangul and Hanja"),
+                 build_string ("ksc5601"));

   Vcharset_japanese_jisx0212 =
   Vcharset_japanese_jisx0212 =

-    make_charset (148, Qjapanese_jisx0212,
-                 LEADING_BYTE_JAPANESE_JISX0212, 3,
+    make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3,

                  CHARSET_TYPE_94X94, 2, 0, 'D',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, 'D',
                  CHARSET_LEFT_TO_RIGHT,

-                 build_string ("JIS X0212 (Japanese Supplement)"),
+                 build_string ("JISX0212"),
+                 build_string ("JISX0212 (Japanese)"),
+                 build_string ("JISX0212 Japanese Supplement"),

                  build_string ("jisx0212"));
 
                  build_string ("jisx0212"));
 

-  /* Chinese */
-  Vcharset_chinese_gb2312 =
-    make_charset (145, Qchinese_gb2312, LEADING_BYTE_CHINESE_GB2312, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'A',
-                 CHARSET_LEFT_TO_RIGHT,
-                 build_string ("GB 2312 (Simplified Chinese)"),
-                 build_string ("gb2312"));

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

-    make_charset (149, Qchinese_cns11643_1,
-                 LEADING_BYTE_CHINESE_CNS11643_1, 3,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 3,

                  CHARSET_TYPE_94X94, 2, 0, 'G',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, 'G',
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("CNS11643-1"),
+                 build_string ("CNS11643-1 (Chinese traditional)"),

                  build_string
                  build_string

-                 ("CNS 11643 Plane 1 (Traditional Chinese for daily use)"),
+                 ("CNS 11643 Plane 1 Chinese traditional"),

                  build_string (CHINESE_CNS_PLANE_RE("1")));
   Vcharset_chinese_cns11643_2 =
                  build_string (CHINESE_CNS_PLANE_RE("1")));
   Vcharset_chinese_cns11643_2 =

-    make_charset (150, Qchinese_cns11643_2,
-                 LEADING_BYTE_CHINESE_CNS11643_2, 3,
+    make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 3,

                  CHARSET_TYPE_94X94, 2, 0, 'H',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, 'H',
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("CNS11643-2"),
+                 build_string ("CNS11643-2 (Chinese traditional)"),

                  build_string
                  build_string

-                 ("CNS 11643 Plane 2 (Traditional Chinese for daily use)"),
+                 ("CNS 11643 Plane 2 Chinese traditional"),

                  build_string (CHINESE_CNS_PLANE_RE("2")));
   Vcharset_chinese_big5_1 =
                  build_string (CHINESE_CNS_PLANE_RE("2")));
   Vcharset_chinese_big5_1 =

-    make_charset (152, Qchinese_big5_1, LEADING_BYTE_CHINESE_BIG5_1, 3,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 3,

                  CHARSET_TYPE_94X94, 2, 0, '0',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, '0',
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("Big5"),
+                 build_string ("Big5 (Level-1)"),

                  build_string
                  build_string

-                 ("Big5 Level 1 (Traditional Chinese for daily use)"),
+                 ("Big5 Level-1 Chinese traditional"),

                  build_string ("big5"));
   Vcharset_chinese_big5_2 =
                  build_string ("big5"));
   Vcharset_chinese_big5_2 =

-    make_charset (153, Qchinese_big5_2, LEADING_BYTE_CHINESE_BIG5_2, 3,
+    make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 3,

                  CHARSET_TYPE_94X94, 2, 0, '1',
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_94X94, 2, 0, '1',
                  CHARSET_LEFT_TO_RIGHT,

+                 build_string ("Big5"),
+                 build_string ("Big5 (Level-2)"),

                  build_string
                  build_string

-                 ("Big5 Level 2 (Traditional Chinese for daily use)"),
+                 ("Big5 Level-2 Chinese traditional"),

                  build_string ("big5"));
 
                  build_string ("big5"));
 

-  Vcharset_korean_ksc5601 =
-    make_charset (147, Qkorean_ksc5601, LEADING_BYTE_KOREAN_KSC5601, 3,
-                 CHARSET_TYPE_94X94, 2, 0, 'C',
-                 CHARSET_LEFT_TO_RIGHT,
-                 build_string ("KS C5601 (Hangul and Korean Hanja)"),
-                 build_string ("ksc5601"));
+
+#ifdef ENABLE_COMPOSITE_CHARS

   /* #### For simplicity, we put composite chars into a 96x96 charset.
      This is going to lead to problems because you can run out of
      room, esp. as we don't yet recycle numbers. */
   Vcharset_composite =
   /* #### For simplicity, we put composite chars into a 96x96 charset.
      This is going to lead to problems because you can run out of
      room, esp. as we don't yet recycle numbers. */
   Vcharset_composite =

-    make_charset (-1, Qcomposite, LEADING_BYTE_COMPOSITE, 3,
+    make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 3,

                  CHARSET_TYPE_96X96, 2, 0, 0,
                  CHARSET_LEFT_TO_RIGHT,
                  CHARSET_TYPE_96X96, 2, 0, 0,
                  CHARSET_LEFT_TO_RIGHT,

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

                  build_string ("Composite characters"),
                  build_string (""));
 
   composite_char_row_next = 32;
   composite_char_col_next = 32;
 
                  build_string ("Composite characters"),
                  build_string (""));
 
   composite_char_row_next = 32;
   composite_char_col_next = 32;
 

-  Vcomposite_char_string2char_hashtable =
-    make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQUAL);
-  Vcomposite_char_char2string_hashtable =
-    make_lisp_hashtable (500, HASHTABLE_NONWEAK, HASHTABLE_EQ);
-  staticpro (&Vcomposite_char_string2char_hashtable);
-  staticpro (&Vcomposite_char_char2string_hashtable);
+  Vcomposite_char_string2char_hash_table =
+    make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
+  Vcomposite_char_char2string_hash_table =
+    make_lisp_hash_table (500, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
+  staticpro (&Vcomposite_char_string2char_hash_table);
+  staticpro (&Vcomposite_char_char2string_hash_table);
+#endif /* ENABLE_COMPOSITE_CHARS */

 
 }
 
 }