--- a/src/mule-charset.c	Mon Aug 13 11:12:06 2007 +0200
+++ b/src/mule-charset.c	Mon Aug 13 11:13:30 2007 +0200
@@ -19,7 +19,7 @@
 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>. */
 
@@ -32,6 +32,7 @@
 #include "lstream.h"
 #include "device.h"
 #include "faces.h"
+#include "mule-ccl.h"
 
 /* The various pre-defined charsets. */
 
@@ -41,23 +42,23 @@
 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_arabic_iso8859_6;
 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_cyrillic_iso8859_5;
+Lisp_Object Vcharset_latin_iso8859_9;
 Lisp_Object Vcharset_japanese_jisx0208_1978;
+Lisp_Object Vcharset_chinese_gb2312;
 Lisp_Object Vcharset_japanese_jisx0208;
+Lisp_Object Vcharset_korean_ksc5601;
 Lisp_Object Vcharset_japanese_jisx0212;
-Lisp_Object Vcharset_chinese_gb2312;
+Lisp_Object Vcharset_chinese_cns11643_1;
+Lisp_Object Vcharset_chinese_cns11643_2;
 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_korean_ksc5601;
 
 #ifdef ENABLE_COMPOSITE_CHARS
 Lisp_Object Vcharset_composite;
@@ -73,11 +74,17 @@
 
 #endif /* ENABLE_COMPOSITE_CHARS */
 
-/* Table of charsets indexed by leading byte. */
-Lisp_Object charset_by_leading_byte[128];
+struct charset_lookup *chlook;
 
-/* Table of charsets indexed by type/final-byte/direction. */
-Lisp_Object charset_by_attributes[4][128][2];
+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 }
+};
+
+static const struct struct_description charset_lookup_description = {
+  sizeof (struct charset_lookup),
+  charset_lookup_description_1
+};
 
 /* Table of number of bytes in the string representation of a character
    indexed by the first byte of that representation.
@@ -85,9 +92,9 @@
    rep_bytes_by_first_byte(c) is more efficient than the equivalent
    canonical computation:
 
-   (BYTE_ASCII_P (c) ? 1 : XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c))) */
+   XCHARSET_REP_BYTES (CHARSET_BY_LEADING_BYTE (c)) */
 
-Bytecount rep_bytes_by_first_byte[0xA0] =
+const Bytecount rep_bytes_by_first_byte[0xA0] =
 { /* 0x00 - 0x7f are for straight ASCII */
   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,
@@ -111,33 +118,33 @@
 Lisp_Object Qregistry, Qfinal, Qgraphic;
 Lisp_Object Qdirection;
 Lisp_Object Qreverse_direction_charset;
-Lisp_Object Qccl_program;
 Lisp_Object Qleading_byte;
+Lisp_Object Qshort_name, Qlong_name;
 
-Lisp_Object Qascii, Qcontrol_1,
-
+Lisp_Object Qascii,
+  Qcontrol_1,
   Qlatin_iso8859_1,
   Qlatin_iso8859_2,
   Qlatin_iso8859_3,
   Qlatin_iso8859_4,
-  Qcyrillic_iso8859_5,
+  Qthai_tis620,
+  Qgreek_iso8859_7,
   Qarabic_iso8859_6,
-  Qgreek_iso8859_7,
   Qhebrew_iso8859_8,
+  Qkatakana_jisx0201,
+  Qlatin_jisx0201,
+  Qcyrillic_iso8859_5,
   Qlatin_iso8859_9,
-
-  Qthai_tis620,
-
-  Qkatakana_jisx0201, Qlatin_jisx0201,
   Qjapanese_jisx0208_1978,
+  Qchinese_gb2312,
   Qjapanese_jisx0208,
+  Qkorean_ksc5601,
   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;
 
@@ -213,7 +220,7 @@
    Use the macro charptr_emchar() instead. */
 
 Emchar
-non_ascii_charptr_emchar (CONST Bufbyte *str)
+non_ascii_charptr_emchar (const Bufbyte *str)
 {
   Bufbyte i0 = *str, i1, i2 = 0;
   Lisp_Object charset;
@@ -260,7 +267,8 @@
       if (f3 < 0x20)
 	return 0;
 
-      if (f3 != 0x20 && f3 != 0x7F)
+      if (f3 != 0x20 && f3 != 0x7F && !(f2 >= MIN_CHAR_FIELD2_PRIVATE &&
+					f2 <= MAX_CHAR_FIELD2_PRIVATE))
 	return 1;
 
       /*
@@ -269,6 +277,8 @@
 	 FIELD2_TO_PRIVATE_LEADING_BYTE are the same.
 	 */
       charset = CHARSET_BY_LEADING_BYTE (f2 + FIELD2_TO_OFFICIAL_LEADING_BYTE);
+      if (EQ (charset, Qnil))
+	return 0;
       return (XCHARSET_CHARS (charset) == 96);
     }
   else
@@ -293,7 +303,8 @@
 	}
 #endif /* ENABLE_COMPOSITE_CHARS */
 
-      if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F)
+      if (f2 != 0x20 && f2 != 0x7F && f3 != 0x20 && f3 != 0x7F
+	  && !(f1 >= MIN_CHAR_FIELD1_PRIVATE && f1 <= MAX_CHAR_FIELD1_PRIVATE))
 	return 1;
 
       if (f1 <= MAX_CHAR_FIELD1_OFFICIAL)
@@ -303,6 +314,8 @@
 	charset =
 	  CHARSET_BY_LEADING_BYTE (f1 + FIELD1_TO_PRIVATE_LEADING_BYTE);
 
+      if (EQ (charset, Qnil))
+	return 0;
       return (XCHARSET_CHARS (charset) == 96);
     }
 }
@@ -317,7 +330,7 @@
    charptr_copy_char() instead. */
 
 Bytecount
-non_ascii_charptr_copy_char (CONST Bufbyte *ptr, Bufbyte *str)
+non_ascii_charptr_copy_char (const Bufbyte *ptr, Bufbyte *str)
 {
   Bufbyte *strptr = str;
   *strptr = *ptr++;
@@ -394,20 +407,22 @@
 /************************************************************************/
 
 static Lisp_Object
-mark_charset (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_charset (Lisp_Object obj)
 {
-  struct Lisp_Charset *cs = XCHARSET (obj);
+  Lisp_Charset *cs = XCHARSET (obj);
 
-  markobj (cs->doc_string);
-  markobj (cs->registry);
-  markobj (cs->ccl_program);
+  mark_object (cs->short_name);
+  mark_object (cs->long_name);
+  mark_object (cs->doc_string);
+  mark_object (cs->registry);
+  mark_object (cs->ccl_program);
   return cs->name;
 }
 
 static void
 print_charset (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-  struct Lisp_Charset *cs = XCHARSET (obj);
+  Lisp_Charset *cs = XCHARSET (obj);
   char buf[200];
 
   if (print_readably)
@@ -418,6 +433,10 @@
   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" :
@@ -434,25 +453,40 @@
   write_c_string (buf, printcharfun);
 }
 
+static const struct lrecord_description charset_description[] = {
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, registry) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) },
+  { XD_END }
+};
+
 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset,
-                               mark_charset, print_charset, 0, 0, 0,
-			       struct Lisp_Charset);
+                               mark_charset, print_charset, 0, 0, 0, charset_description,
+			       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,
-	      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 =
-    alloc_lcrecord_type (struct Lisp_Charset, lrecord_charset);
+  Lisp_Charset *cs = alloc_lcrecord_type (Lisp_Charset, &lrecord_charset);
+
+  zero_lcrecord (cs);
+
   XSETCHARSET (obj, cs);
 
   CHARSET_ID		(cs) = id;
   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;
@@ -474,15 +508,12 @@
       /* some charsets do not have final characters.  This includes
 	 ASCII, Control-1, Composite, and the two faux private
 	 charsets. */
-      assert (NILP (charset_by_attributes[type][final][direction]));
-      charset_by_attributes[type][final][direction] = obj;
+      assert (NILP (chlook->charset_by_attributes[type][final][direction]));
+      chlook->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)
-    /* official leading byte */
-    rep_bytes_by_first_byte[leading_byte] = rep_bytes;
+  assert (NILP (chlook->charset_by_leading_byte[id - 128]));
+  chlook->charset_by_leading_byte[id - 128] = obj;
 
   /* Some charsets are "faux" and don't have names or really exist at
      all except in the leading-byte table. */
@@ -616,6 +647,8 @@
 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.
@@ -655,13 +688,14 @@
 */
        (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;
+  Lisp_Object short_name = Qnil, long_name = Qnil;
 
   CHECK_SYMBOL (name);
   if (!NILP (doc_string))
@@ -673,7 +707,19 @@
 
   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);
@@ -756,7 +802,7 @@
     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 ("");
@@ -764,10 +810,16 @@
   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;
-  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;
@@ -781,10 +833,10 @@
        (charset, new_name))
 {
   Lisp_Object new_charset = Qnil;
-  int lb, dimension, columns, graphic, final;
+  int id, dimension, columns, graphic, final;
   int direction, type;
-  Lisp_Object registry, doc_string;
-  struct Lisp_Charset *cs;
+  Lisp_Object registry, doc_string, short_name, long_name;
+  Lisp_Charset *cs;
 
   charset = Fget_charset (charset);
   if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
@@ -800,7 +852,7 @@
   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);
@@ -808,10 +860,13 @@
   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);
 
-  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;
@@ -891,8 +946,24 @@
   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))
 {
@@ -914,13 +985,15 @@
 */
        (charset, prop))
 {
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
 
   charset = Fget_charset (charset);
   cs = XCHARSET (charset);
 
   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));
@@ -929,7 +1002,6 @@
   if (EQ (prop, Qchars))       return make_int (CHARSET_CHARS (cs));
   if (EQ (prop, Qregistry))    return CHARSET_REGISTRY (cs);
   if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs);
-  if (EQ (prop, Qleading_byte)) return make_char (CHARSET_LEADING_BYTE (cs));
   if (EQ (prop, Qdirection))
     return CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? Ql2r : Qr2l;
   if (EQ (prop, Qreverse_direction_charset))
@@ -949,7 +1021,7 @@
 */
 	(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
@@ -1000,11 +1072,14 @@
 /************************************************************************/
 
 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))
 {
-  struct Lisp_Charset *cs;
+  Lisp_Charset *cs;
   int a1, a2;
   int lowlim, highlim;
 
@@ -1017,7 +1092,11 @@
   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));
 
@@ -1030,7 +1109,7 @@
     }
 
   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));
 
@@ -1055,20 +1134,47 @@
        (ch, n))
 {
   Lisp_Object charset;
-  int c1, c2, int_n;
+  int octet0, octet1;
 
   CHECK_CHAR_COERCE_INT (ch);
-  if (NILP (n))
-    int_n = 0;
+
+  BREAKUP_CHAR (XCHAR (ch), charset, octet0, octet1);
+
+  if (NILP (n) || EQ (n, Qzero))
+    return make_int (octet0);
+  else if (EQ (n, make_int (1)))
+    return make_int (octet1);
+  else
+    signal_simple_error ("Octet number must be 0 or 1", n);
+}
+
+DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
+Return list of charset and one or two position-codes of CHAR.
+*/
+       (character))
+{
+  /* This function can GC */
+  struct gcpro gcpro1, gcpro2;
+  Lisp_Object charset = Qnil;
+  Lisp_Object rc = Qnil;
+  int c1, c2;
+
+  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
     {
-      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;
 }
 
 
@@ -1162,7 +1268,9 @@
   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);
@@ -1172,6 +1280,7 @@
   DEFSUBR (Fmake_char);
   DEFSUBR (Fchar_charset);
   DEFSUBR (Fchar_octet);
+  DEFSUBR (Fsplit_char);
 
 #ifdef ENABLE_COMPOSITE_CHARS
   DEFSUBR (Fmake_composite_char);
@@ -1184,13 +1293,13 @@
   defsymbol (&Qgraphic, "graphic");
   defsymbol (&Qdirection, "direction");
   defsymbol (&Qreverse_direction_charset, "reverse-direction-charset");
-  defsymbol (&Qccl_program, "ccl-program");
-  defsymbol (&Qleading_byte, "leading-byte");
+  defsymbol (&Qshort_name, "short-name");
+  defsymbol (&Qlong_name, "long-name");
 
   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");
@@ -1198,26 +1307,24 @@
   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 (&Qthai_tis620,		"thai-tis620");
+  defsymbol (&Qgreek_iso8859_7,		"greek-iso8859-7");
   defsymbol (&Qarabic_iso8859_6,	"arabic-iso8859-6");
-  defsymbol (&Qgreek_iso8859_7,		"greek-iso8859-7");
   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 (&Qcyrillic_iso8859_5, 	"cyrillic-iso8859-5");
+  defsymbol (&Qlatin_iso8859_9,		"latin-iso8859-9");
   defsymbol (&Qjapanese_jisx0208_1978,	"japanese-jisx0208-1978");
+  defsymbol (&Qchinese_gb2312,		"chinese-gb2312");
   defsymbol (&Qjapanese_jisx0208, 	"japanese-jisx0208");
+  defsymbol (&Qkorean_ksc5601,		"korean-ksc5601");
   defsymbol (&Qjapanese_jisx0212,	"japanese-jisx0212");
-
-  defsymbol (&Qchinese_gb2312,		"chinese-gb2312");
+  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 (&Qchinese_cns11643_1,	"chinese-cns11643-1");
-  defsymbol (&Qchinese_cns11643_2,	"chinese-cns11643-2");
 
-  defsymbol (&Qkorean_ksc5601,		"korean-ksc5601");
   defsymbol (&Qcomposite,		"composite");
 }
 
@@ -1226,15 +1333,18 @@
 {
   int i, j, k;
 
+  chlook = xnew (struct charset_lookup);
+  dumpstruct (&chlook, &charset_lookup_description);
+
   /* Table of charsets indexed by leading byte. */
-  for (i = 0; i < countof (charset_by_leading_byte); i++)
-    charset_by_leading_byte[i] = Qnil;
+  for (i = 0; i < countof (chlook->charset_by_leading_byte); i++)
+    chlook->charset_by_leading_byte[i] = Qnil;
 
   /* Table of charsets indexed by type/final-byte/direction. */
-  for (i = 0; i < countof (charset_by_attributes); i++)
-    for (j = 0; j < countof (charset_by_attributes[0]); j++)
-      for (k = 0; k < countof (charset_by_attributes[0][0]); k++)
-	charset_by_attributes[i][j][k] = Qnil;
+  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;
 
   next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1;
   next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2;
@@ -1250,174 +1360,237 @@
   /* Predefined character sets.  We store them into variables for
      ease of access. */
 
+  staticpro (&Vcharset_ascii);
   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,
-		  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\\)"));
+  staticpro (&Vcharset_control_1);
   Vcharset_control_1 =
-    make_charset (-1, Qcontrol_1, LEADING_BYTE_CONTROL_1, 2,
+    make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 2,
 		  CHARSET_TYPE_94, 1, 1, 0,
 		  CHARSET_LEFT_TO_RIGHT,
+		  build_string ("C1"),
 		  build_string ("Control characters"),
+		  build_string ("Control characters 128-191"),
 		  build_string (""));
+  staticpro (&Vcharset_latin_iso8859_1);
   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,
-		  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"));
+  staticpro (&Vcharset_latin_iso8859_2);
   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,
-		  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"));
+  staticpro (&Vcharset_latin_iso8859_3);
   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,
-		  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"));
+  staticpro (&Vcharset_latin_iso8859_4);
   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,
-		  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"));
-  Vcharset_cyrillic_iso8859_5 =
-    make_charset (140, Qcyrillic_iso8859_5, LEADING_BYTE_CYRILLIC_ISO8859_5, 2,
-		  CHARSET_TYPE_96, 1, 1, 'L',
-		  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"));
-  Vcharset_greek_iso8859_7 =
-    make_charset (134, Qgreek_iso8859_7, LEADING_BYTE_GREEK_ISO8859_7, 2,
-		  CHARSET_TYPE_96, 1, 1, 'F',
-		  CHARSET_LEFT_TO_RIGHT,
-		  build_string ("ISO 8859-7 (Greek)"),
-		  build_string ("iso8859-7"));
-  Vcharset_hebrew_iso8859_8 =
-    make_charset (136, Qhebrew_iso8859_8, LEADING_BYTE_HEBREW_ISO8859_8, 2,
-		  CHARSET_TYPE_96, 1, 1, 'H',
-		  CHARSET_RIGHT_TO_LEFT,
-		  build_string ("ISO 8859-8 (Hebrew)"),
-		  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"));
+  staticpro (&Vcharset_thai_tis620);
   Vcharset_thai_tis620 =
-    make_charset (133, Qthai_tis620, LEADING_BYTE_THAI_TIS620, 2,
+    make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2,
 		  CHARSET_TYPE_96, 1, 1, 'T',
 		  CHARSET_LEFT_TO_RIGHT,
-		  build_string ("TIS 620.2529 (Thai)"),
+		  build_string ("TIS620"),
+		  build_string ("TIS620 (Thai)"),
+		  build_string ("TIS620.2529 (Thai)"),
 		  build_string ("tis620"));
-
-  /* Japanese */
+  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,
+		  build_string ("ISO8859-7"),
+		  build_string ("ISO8859-7 (Greek)"),
+		  build_string ("ISO8859-7 (Greek)"),
+		  build_string ("iso8859-7"));
+  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,
+		  build_string ("ISO8859-6"),
+		  build_string ("ISO8859-6 (Arabic)"),
+		  build_string ("ISO8859-6 (Arabic)"),
+		  build_string ("iso8859-6"));
+  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,
+		  build_string ("ISO8859-8"),
+		  build_string ("ISO8859-8 (Hebrew)"),
+		  build_string ("ISO8859-8 (Hebrew)"),
+		  build_string ("iso8859-8"));
+  staticpro (&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,
-		  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"));
+  staticpro (&Vcharset_latin_jisx0201);
   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,
-		  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"));
+  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,
+		  build_string ("ISO8859-5"),
+		  build_string ("ISO8859-5 (Cyrillic)"),
+		  build_string ("ISO8859-5 (Cyrillic)"),
+		  build_string ("iso8859-5"));
+  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,
+		  build_string ("Latin-5"),
+		  build_string ("ISO8859-9 (Latin-5)"),
+		  build_string ("ISO8859-9 (Latin-5)"),
+		  build_string ("iso8859-9"));
+  staticpro (&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,
+		  build_string ("JISX0208.1978"),
+		  build_string ("JISX0208.1978 (Japanese)"),
 		  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"));
+  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,
+		  build_string ("GB2312"),
+		  build_string ("GB2312)"),
+		  build_string ("GB2312 Chinese simplified"),
+		  build_string ("gb2312"));
+  staticpro (&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,
-		  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\\)"));
+  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,
+		  build_string ("KSC5601"),
+		  build_string ("KSC5601 (Korean"),
+		  build_string ("KSC5601 Korean Hangul and Hanja"),
+		  build_string ("ksc5601"));
+  staticpro (&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,
-		  build_string ("JIS X0212 (Japanese Supplement)"),
+		  build_string ("JISX0212"),
+		  build_string ("JISX0212 (Japanese)"),
+		  build_string ("JISX0212 Japanese Supplement"),
 		  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 "$"
+  staticpro (&Vcharset_chinese_cns11643_1);
   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,
+		  build_string ("CNS11643-1"),
+		  build_string ("CNS11643-1 (Chinese traditional)"),
 		  build_string
-		  ("CNS 11643 Plane 1 (Traditional Chinese for daily use)"),
+		  ("CNS 11643 Plane 1 Chinese traditional"),
 		  build_string (CHINESE_CNS_PLANE_RE("1")));
+  staticpro (&Vcharset_chinese_cns11643_2);
   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,
+		  build_string ("CNS11643-2"),
+		  build_string ("CNS11643-2 (Chinese traditional)"),
 		  build_string
-		  ("CNS 11643 Plane 2 (Traditional Chinese for daily use)"),
+		  ("CNS 11643 Plane 2 Chinese traditional"),
 		  build_string (CHINESE_CNS_PLANE_RE("2")));
+  staticpro (&Vcharset_chinese_big5_1);
   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,
+		  build_string ("Big5"),
+		  build_string ("Big5 (Level-1)"),
 		  build_string
-		  ("Big5 Level 1 (Traditional Chinese for daily use)"),
+		  ("Big5 Level-1 Chinese traditional"),
 		  build_string ("big5"));
+  staticpro (&Vcharset_chinese_big5_2);
   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,
+		  build_string ("Big5"),
+		  build_string ("Big5 (Level-2)"),
 		  build_string
-		  ("Big5 Level 2 (Traditional Chinese for daily use)"),
+		  ("Big5 Level-2 Chinese traditional"),
 		  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. */
+  staticpro (&Vcharset_composite);
   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,
+		  build_string ("Composite"),
+		  build_string ("Composite characters"),
 		  build_string ("Composite characters"),
 		  build_string (""));
 
+  /* #### not dumped properly */
   composite_char_row_next = 32;
   composite_char_col_next = 32;