(Qprepend, Qappend): New variables.

(FONTSET_CHARSET_ALIST, FONTSET_FACE_ALIST): These macros deleted.
(FONTSET_NOFONT_FACE, FONTSET_REPERTORY): New macros.
(FONTSET_REF): Optimize if FONTSET is Vdefault_fontset.
(FONTSET_REF_AND_RANGE, FONTSET_ADD): New macros.
(fontset_ref_and_range, fontset_add, reorder_font_vector)
(load_font_get_repertory): New functions.
(fontset_set): This function deleted.
(fontset_face): New arg FACE.  Return face ID, not face.
Completely re-written to handle new fontset structure.  Caller
changed.
(free_face_fontset): Use ASET istead of AREF (X) = Y.
(face_for_char): Don't call lookup_face.
(make_fontset_for_ascii_face): New arg FACE.
(fs_load_font): New arg CHARSET_ID.  Don't check
Vfont_encoding_alist here.
(find_font_encoding): New function.
(list_fontsets): Use STRINGP, not ! NILP.
(accumulate_script_ranges): New function.
(Fset_fontset_font, Fnew_fontset, Ffontset_info): Completely
re-written to handle new fontset structure.
(Ffontset_font): Return a copy of element.
(syms_of_fontset): Define symbols Qprepend and Qappend.  Fix
docstring of font-encoding-alist.

1 files changed, 745 insertions, 410 deletions

diff --git a/src/fontset.c b/src/fontset.c
index 05db03e100c..fb6600da254 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -54,61 +54,105 @@ EXFUN (Fclear_face_cache, 1);
 /* FONTSET
 
    A fontset is a collection of font related information to give
-   similar appearance (style, etc) of characters.  There are two kinds
-   of fontsets; base and realized.  A base fontset is created by
-   `new-fontset' from Emacs Lisp explicitly.  A realized fontset is
-   created implicitly when a face is realized for ASCII characters.  A
-   face is also realized for non-ASCII characters based on an ASCII
-   face.  All of non-ASCII faces based on the same ASCII face share
-   the same realized fontset.
+   similar appearance (style, etc) of characters.  A fontset has two
+   roles.  One is to use for the frame parameter `font' as if it is an
+   ASCII font.  In that case, Emacs uses the font specified for
+   `ascii' script for the frame's default font.
+
+   Another role, the more important one, is to provide information
+   about which font to use for each non-ASCII character.
+
+   There are two kinds of fontsets; base and realized.  A base fontset
+   is created by `new-fontset' from Emacs Lisp explicitly.  A realized
+   fontset is created implicitly when a face is realized for ASCII
+   characters.  A face is also realized for non-ASCII characters based
+   on an ASCII face.  All of non-ASCII faces based on the same ASCII
+   face share the same realized fontset.
    
    A fontset object is implemented by a char-table whose default value
    and parent are always nil.
 
-   An element of a base fontset is a font specification of the form:
-        [ FAMILY WEIGHT SLANT SWIDTH REGISTRY ] (vector of size 5)
+   An element of a base fontset is a vector of FONT-DEFs which itself
+   is a vector [ FONT-SPEC ENCODING REPERTORY ].
+
+   FONT-SPEC is:
+        [ FAMILY WEIGHT SLANT SWIDTH ADSTYLE REGISTRY ]
    or
-        FONT-NAME (strig)
+        FONT-NAME
+   where FAMILY, WEIGHT, SLANT, SWIDTH, ADSTYLE, REGISTRY, and
+   FONT-NAME are strings.
+
+   ENCODING is a charset ID or a char-table that can convert
+   characters to glyph codes of the corresponding font.
+
+   REPERTORY is a charset ID or nil.  If REPERTORY is a charset ID,
+   the repertory of the charset exactly matches with that of the font.
+   If REPERTORY is nil, we consult with the font itself to get the
+   repertory.
+
+   ENCODING and REPERTORY are extracted from the variable
+   Vfont_encoding_alist by using a font name generated form FONT-SPEC
+   (if it is a vector) or FONT-NAME as a key.
+
+
+   An element of a realized fontset is nil or t, or has this form:
+
+        ( CHARSET-PRIORITY-LIST-TICK . FONT-VECTOR )
+
+   FONT-VECTOR is a vector whose elements have this form:
+
+        [ FACE-ID FONT-INDEX FONT-DEF ]
 
-   FAMILY and REGISTRY are strings.
+   FONT-VECTOR is automatically reordered by the current charset
+   priority list.
 
-   WEIGHT, SLANT, and SWIDTH must be symbols that set-face-attribute
-   accepts as attribute values for :weight, :slant, :swidth
-   respectively.
+   The value nil means that we have not yet generated FONT-VECTOR from
+   the base of the fontset.
 
+   The value t means that no font is available for the corresponding
+   range of characters.
 
-   A fontset has 7 extra slots.
 
-   The 1st slot is an ID number of the fontset.
+   A fontset has 5 extra slots.
 
-   The 2nd slot is a name of the fontset in a base fontset, and nil in
-   a realized fontset.
+   The 1st slot: the ID number of the fontset
 
-   The 3rd slot is nil in a base fontset, and a base fontset in a
-   realized fontset.
+   The 2nd slot:
+        base: the name of the fontset
+        realized: nil
 
-   The 4th slot is a frame that the fontset belongs to.  This is nil
-   in a base fontset.
+   The 3rd slot:
+        base: nli
+        realized: the base fontset
 
-   The 5th slot is a cons of 0 and fontname for ASCII characters in a
-   base fontset, and nil in a realized face.
+   The 4th slot:
+        base: nil
+        realized: the frame that the fontset belongs to
 
-   The 6th slot is an alist of a charset vs. the corresponding font
-   specification.
+   The 5th slot:
+        base: the font name for ASCII characters
+        realized: nil
 
-   The 7th slot is an alist of a font specification vs. the
-   corresponding face ID.  In a base fontset, the face IDs are all
-   nil.
+   The 6th slot:
+        base: nil
+        realized: the ID number of a face to use for characters that
+                  has no font in a realized fontset.
 
-   All fontsets are recorded in Vfontset_table.
+   The 7th slot:
+        base: nil
+        realized: Alist of font index vs the corresponding repertory
+        char-table.
+        
+
+   All fontsets are recorded in the vector Vfontset_table.
 
 
    DEFAULT FONTSET
 
-   There's a special fontset named `default fontset' which defines the
-   default font specifications.  When a base fontset doesn't specify a
-   font for a specific character, the corresponding value in the
-   default fontset is used.  The format is the same as a base fontset.
+   There's a special base fontset named `default fontset' which
+   defines the default font specifications.  When a base fontset
+   doesn't specify a font for a specific character, the corresponding
+   value in the default fontset is used.
 
    The parent of a realized fontset created for such a face that has
    no fontset is the default fontset.
@@ -118,7 +162,7 @@ EXFUN (Fclear_face_cache, 1);
    The other codes handle fontsets only by their ID numbers.  They
    usually use the variable name `fontset' for IDs.  But, in this
    file, we always use varialbe name `id' for IDs, and name `fontset'
-   for the actual fontset objects (i.e. char-table objects).
+   for an actual fontset object, i.e., char-table.
 
 */
 
@@ -126,6 +170,7 @@ EXFUN (Fclear_face_cache, 1);
 
 extern Lisp_Object Qfont;
 Lisp_Object Qfontset;
+static Lisp_Object Qprepend, Qappend;
 
 /* Vector containing all fontsets.  */
 static Lisp_Object Vfontset_table;
@@ -176,6 +221,9 @@ void (*set_frame_fontset_func) P_ ((FRAME_PTR f, Lisp_Object arg,
    This function set the member `encoder' of the structure.  */
 void (*find_ccl_program_func) P_ ((struct font_info *));
 
+Lisp_Object (*get_font_repertory_func) P_ ((struct frame *,
+                                            struct font_info *));
+
 /* Check if any window system is used now.  */
 void (*check_window_system_func) P_ ((void));
 
@@ -184,6 +232,9 @@ void (*check_window_system_func) P_ ((void));
 static Lisp_Object make_fontset P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
 static int fontset_id_valid_p P_ ((int));
 static Lisp_Object fontset_pattern_regexp P_ ((Lisp_Object));
+static void accumulate_script_ranges P_ ((Lisp_Object, Lisp_Object,
+                                          Lisp_Object));
+
 
 
 /********** MACROS AND FUNCTIONS TO HANDLE FONTSET **********/
@@ -203,13 +254,19 @@ static Lisp_Object fontset_pattern_regexp P_ ((Lisp_Object));
 /* Macros to access special values of (realized) FONTSET.  */
 #define FONTSET_BASE(fontset)           XCHAR_TABLE (fontset)->extras[2]
 #define FONTSET_FRAME(fontset)          XCHAR_TABLE (fontset)->extras[3]
-#define FONTSET_CHARSET_ALIST(fontset)  XCHAR_TABLE (fontset)->extras[5]
-#define FONTSET_FACE_ALIST(fontset)     XCHAR_TABLE (fontset)->extras[6]
+#define FONTSET_NOFONT_FACE(fontset)    XCHAR_TABLE (fontset)->extras[5]
+#define FONTSET_REPERTORY(fontset)      XCHAR_TABLE (fontset)->extras[6]
 
 
-/* Return the element of FONTSET (char-table) at index C (character).  */
+/* Return the element of FONTSET for the character C.  If FONTSET is a
+   base fontset other then the default fontset and FONTSET doesn't
+   contain information for C, return the information in the default
+   fontset.  */
 
-#define FONTSET_REF(fontset, c, etl)    ((elt) = fontset_ref ((fontset), (c)))
+#define FONTSET_REF(fontset, c)         \
+  (EQ (fontset, Vdefault_fontset)       \
+   ? CHAR_TABLE_REF (fontset, c)        \
+   : fontset_ref ((fontset), (c)))
 
 static Lisp_Object
 fontset_ref (fontset, c)
@@ -218,105 +275,336 @@ fontset_ref (fontset, c)
 {
   Lisp_Object elt;
 
-  while (1)
+  elt = CHAR_TABLE_REF (fontset, c);
+  if (NILP (elt) && ! EQ (fontset, Vdefault_fontset)
+      /* Don't check Vdefault_fontset for a realized fontset.  */
+      && NILP (FONTSET_BASE (fontset)))
+    elt = CHAR_TABLE_REF (Vdefault_fontset, c);
+  return elt;
+}
+
+
+/* Return the element of FONTSET for the character C, set FROM and TO
+   to the range of characters around C that have the same value as C.
+   If FONTSET is a base fontset other then the default fontset and
+   FONTSET doesn't contain information for C, return the information
+   in the default fontset.  */
+
+#define FONTSET_REF_AND_RANGE(fontset, c, form, to)     \
+  (EQ (fontset, Vdefault_fontset)                       \
+   ? char_table_ref_and_range (fontset, c, &from, &to)  \
+   : fontset_ref_and_range (fontset, c, &from, &to))
+
+static Lisp_Object
+fontset_ref_and_range (fontset, c, from, to)
+     Lisp_Object fontset;
+     int c;
+     int *from, *to;
+{
+  Lisp_Object elt;
+
+  elt = char_table_ref_and_range (fontset, c, from, to);
+  if (NILP (elt) && ! EQ (fontset, Vdefault_fontset)
+      /* Don't check Vdefault_fontset for a realized fontset.  */
+      && NILP (FONTSET_BASE (fontset)))
     {
-      elt = CHAR_TABLE_REF (fontset, c);
-      if (NILP (elt) && ASCII_CHAR_P (c))
-        elt = FONTSET_ASCII (fontset);
-      if (NILP (elt))
-        {
-          Lisp_Object tail;
-          struct charset *charset;
+      int from1, to1;
 
-          for (tail = FONTSET_CHARSET_ALIST (fontset);
-               CONSP (tail);  tail = XCDR (tail))
-            {
-              charset = CHARSET_FROM_ID (XINT (XCAR (XCAR (tail))));
-              if (ENCODE_CHAR (charset, c) != CHARSET_INVALID_CODE (charset))
-                {
-                  elt = XCDR (XCAR (tail));
-                  break;
-                }
-            }
-        }
-      if (! NILP (elt) || EQ (fontset, Vdefault_fontset))
-        break;
-      fontset = Vdefault_fontset;
+      elt = char_table_ref_and_range (Vdefault_fontset, c, &from1, &to1);
+      if (*from < from1)
+        *from = from1;
+      if (*to > to1)
+        *to = to1;
     }
   return elt;
 }
 
 
-/* Set the element of FONTSET at index IDX to the value ELT.  IDX may
-   be a character or a charset.  */
+/* Set elements of FONTSET for characters in RANGE to the value ELT.
+   RANGE is a cons (FROM . TO), where FROM and TO are character codes
+   specifying a range.  */
+
+#define FONTSET_SET(fontset, range, elt)        \
+  Fset_char_table_range ((fontset), (range), (elt))
+
 
-#define FONTSET_SET(fontset, c, newelt) fontset_set(fontset, c, newelt)
+/* Modify the elements of FONTSET for characters in RANGE by replacing
+   with ELT or adding ETL.  RANGE is a cons (FROM . TO), where FROM
+   and TO are character codes specifying a range.  If ADD is nil,
+   replace with ELT, if ADD is `prepend', prepend ELT, otherwise,
+   append ELT.  */
+
+#define FONTSET_ADD(fontset, range, elt, add)                           \
+  (NILP (add)                                                           \
+   ? Fset_char_table_range ((fontset), (range),                         \
+                            Fmake_vector (make_number (1), (elt)))      \
+   : fontset_add ((fontset), (range), (elt), (add)))
 
 static void
-fontset_set (fontset, idx, elt)
-     Lisp_Object fontset, idx, elt;
+fontset_add (fontset, range, elt, add)
 {
-  if (SYMBOLP (idx))
+  int from, to, from1, to1;
+  Lisp_Object elt1;
+  
+  from = XINT (XCAR (range));
+  to = XINT (XCDR (range));
+  do {
+    elt1 = char_table_ref_and_range (fontset, from, &from1, &to1);
+    if (NILP (elt1))
+      elt1 = Fmake_vector (make_number (1), elt);
+    else
+      {
+        int i, i0 = 1, i1 = ASIZE (elt1) + 1;
+        Lisp_Object new;
+
+        new = Fmake_vector (i1, elt);
+        if (EQ (add, Qappend))
+          i0--, i1--;
+        for (i = 0; i0 < i1; i++, i0++)
+          ASET (new, i0, AREF (elt1, i));
+        elt1 = new;
+      }
+    char_table_set_range (fontset, from, to1, elt1);    
+    from = to1 + 1;
+  } while (from < to);
+}
+
+
+/* Update FONTSET_ELEMENT which has this form:
+        ( CHARSET-PRIORITY-LIST-TICK . FONT-VECTOR).
+   Reorder FONT-VECTOR according to the current order of charset
+   (Vcharset_ordered_list), and update CHARSET-PRIORITY-LIST-TICK to
+   the latest value.  */
+
+static void
+reorder_font_vector (fontset_element)
+     Lisp_Object fontset_element;
+{
+  Lisp_Object vec, list, *new_vec;
+  int size;
+  int *charset_id_table;
+  int i, idx;
+
+  XSETCAR (fontset_element, make_number (charset_ordered_list_tick));
+  vec = XCDR (fontset_element);
+  size = ASIZE (vec);
+  if (size < 2)
+    /* No need of reordering VEC.  */
+    return;
+  charset_id_table = (int *) alloca (sizeof (int) * size);
+  new_vec = (Lisp_Object *) alloca (sizeof (Lisp_Object) * size);
+  /* At first, extract ENCODING (a chaset ID) from VEC.  VEC has this
+     form:
+        [[FACE-ID FONT-INDEX [ FONT-SPEC ENCODING REPERTORY ]] ...] */
+  for (i = 0; i < size; i++)
+    charset_id_table[i] = XINT (AREF (AREF (AREF (vec, i), 2), 1));
+
+  /* Then, store the elements of VEC in NEW_VEC in the correct
+     order.  */
+  idx = 0;
+  for (list = Vcharset_ordered_list; CONSP (list); list = XCDR (list))
     {
-      Lisp_Object id, slot, tail;
-      
-      id = CHARSET_SYMBOL_ID (idx);
-      if (XFASTINT (id) == charset_ascii)
-        Fset_char_table_range (fontset,
-                               Fcons (make_number (0), make_number (127)),
-                               elt);
-      else
-        {
-          slot = Fassq (id, FONTSET_CHARSET_ALIST (fontset));
-          if (CONSP (slot))
-            XCDR (slot) = elt;
-          else if (CONSP (FONTSET_CHARSET_ALIST (fontset)))
-            {
-              for (tail = FONTSET_CHARSET_ALIST (fontset);
-                   CONSP (XCDR (tail)); tail = XCDR (tail));
-              XCDR (tail) = Fcons (Fcons (id, elt), Qnil);
-            }
-          else
-            FONTSET_CHARSET_ALIST (fontset) = Fcons (Fcons (id, elt), Qnil);
-        }
+      for (i = 0; i < size; i++)
+        if (charset_id_table[i] == XINT (XCAR (list)))
+          new_vec[idx++] = AREF (vec, i);
+      if (idx == size)
+        break;
     }
-  else
-    {
-      int from = XINT (XCAR (idx));
-      int to = XINT (XCDR (idx));
 
-      if (from == to)
-        CHAR_TABLE_SET (fontset, from, elt);
-      else
-        Fset_char_table_range (fontset, idx, elt);
+  /* At last, update VEC.  */
+  for (i = 0; i < size; i++)
+    ASET (vec, i, new_vec[i]);
+}
+
+
+/* Load a font matching the font related attributes in FACE->lface and
+   font pattern in FONT_DEF of FONTSET, and return an index of the
+   font.  FONT_DEF has this form:
+        [ FONT-SPEC ENCODING REPERTORY ]
+   If REPERTORY is nil, generate a char-table representing the font
+   repertory by looking into the font itself.  */
+
+static int
+load_font_get_repertory (f, face, font_def, fontset)
+     FRAME_PTR f;
+     struct face *face;
+     Lisp_Object font_def;
+     Lisp_Object fontset;
+{
+  char *font_name;
+  struct font_info *font_info;
+
+  font_name = choose_face_font (f, face->lface, AREF (font_def, 0));
+  if (! (font_info = fs_load_font (f, font_name, XINT (AREF (font_def, 1)))))
+    return -1;
+
+  if (NILP (AREF (font_def, 2))
+      && NILP (Fassq (make_number (font_info->font_idx),
+                      FONTSET_REPERTORY (fontset))))
+    {
+      /* We must look into the font to get the correct repertory as a
+         char-table.  */
+      Lisp_Object repertory;
+
+      repertory = (*get_font_repertory_func) (f, font_info);
+      FONTSET_REPERTORY (fontset)
+        = Fcons (Fcons (make_number (font_info->font_idx), repertory),
+                 FONTSET_REPERTORY (fontset));         
     }
+        
+  return font_info->font_idx;
 }
 
 
-/* Return a face registerd in the realized fontset FONTSET for the
-   character C.  Return -1 if a face ID is not yet set.  */
+/* Return a face ID registerd in the realized fontset FONTSET for the
+   character C.  If FACE is NULL, return -1 if a face is not yet
+   set.  Otherwise, realize a proper face from FACE and return it.  */
 
-static struct face *
-fontset_face (fontset, c)
+static int
+fontset_face (fontset, c, face)
      Lisp_Object fontset;
      int c;
+     struct face *face;
 {
-  Lisp_Object base, elt;
-  int id;
-  struct face *face;
+  Lisp_Object elt, vec;
+  int i, from, to;
+  int font_idx;
+  FRAME_PTR f = XFRAME (FONTSET_FRAME (fontset));
 
-  base = FONTSET_BASE (fontset);
-  FONTSET_REF (base, c, elt);
+  elt = CHAR_TABLE_REF (fontset, c);
 
+  if (EQ (elt, Qt))
+    goto font_not_found;
   if (NILP (elt))
-    return NULL;
+    {
+      /* We have not yet decided a face for C.  */
+      Lisp_Object base_fontset, range;
+
+      if (! face)
+        return -1;
+      base_fontset = FONTSET_BASE (fontset);
+      elt = FONTSET_REF_AND_RANGE (base_fontset, c, from, to);
+      range = Fcons (make_number (from), make_number (to));
+      if (NILP (elt))
+        {
+          /* Record that we have no font for characters of this
+             range.  */
+          FONTSET_SET (fontset, range, Qt);
+          goto font_not_found;
+        }
+      elt = Fcopy_sequence (elt);
+      /* Now ELT is a vector of FONT-DEFs.  We at first change it to
+         FONT-VECTOR, a vector of [ nil nil FONT-DEF ].  */
+      for (i = 0; i < ASIZE (elt); i++)
+        {
+          Lisp_Object tmp;
 
-  elt = Fassoc (elt, FONTSET_FACE_ALIST (fontset));
-  if (! CONSP (elt))
-    return NULL;
-  id = XINT (XCDR (elt));
-  face = FACE_FROM_ID (XFRAME (FONTSET_FRAME (fontset)), id);
-  return face;
+          tmp = Fmake_vector (make_number (3), Qnil);
+          ASET (tmp, 2, AREF (elt, i));
+          ASET (elt, i, tmp);
+        }
+      /* Then store (-1 . FONT-VECTOR) in the fontset.  -1 is to force
+         reordering of FONT-VECTOR.  */
+      elt = Fcons (make_number (-1), elt);
+      FONTSET_SET (fontset, range, elt);
+    }
+
+  if (XINT (XCAR (elt)) != charset_ordered_list_tick)
+    /* The priority of charsets is changed after we selected a face
+       for C last time.  */
+    reorder_font_vector (elt);
+
+  vec = XCDR (elt);
+  /* Find the first available font in the font vector VEC.  */
+  for (i = 0; i < ASIZE (vec); i++)
+    {
+      Lisp_Object font_def;
+
+      elt = AREF (vec, i);
+      /* ELT == [ FACE-ID FONT-INDEX [ FONT-SPEC ENCODING REPERTORY ] ] */
+      font_def = AREF (elt, 2);
+      if (INTEGERP (AREF (elt, 1)) && XINT (AREF (elt, 1)) < 0)
+        /* We couldn't open this font last time.  */
+        continue;
+
+      if (!face && (NILP (AREF (elt, 1)) || NILP (AREF (elt, 0))))
+        /* We have not yet opened the font, or we have not yet made a
+           realized face for the font.  */
+        return -1;
+
+      if (INTEGERP (AREF (font_def, 2)))
+        {
+          /* The repertory is specified by charset ID.  */
+          struct charset *charset
+            = CHARSET_FROM_ID (XINT (AREF (font_def, 2)));
+
+          if (! CHAR_CHARSET_P (c, charset))
+            /* This fond can't display C.  */
+            continue;
+        }
+      else
+        {
+          Lisp_Object slot;
+
+          if (! INTEGERP (AREF (elt, 1)))
+            {
+              /* We have not yet opened a font matching this spec.
+                 Open the best matching font now and register the
+                 repertory.  */
+              font_idx = load_font_get_repertory (f, face, font_def, fontset);
+              ASET (elt, 1, make_number (font_idx));
+              if (font_idx < 0)
+                /* This means that we couldn't find a font matching
+                   FONT_DEF.  */
+                continue;
+            }
+
+          slot = Fassq (AREF (elt, 1), FONTSET_REPERTORY (fontset));
+          if (! CONSP (slot))
+            abort ();
+          if (NILP (CHAR_TABLE_REF (XCDR (slot), c)))
+            /* This fond can't display C.  */
+            continue;
+        }
+
+      /* Now we have decided to use this font spec to display C.  */
+      if (INTEGERP (AREF (elt, 1)))
+        font_idx = XINT (AREF (elt, 1));
+      else
+        {
+          /* But not yet opened the best matching font.  */
+          font_idx = load_font_get_repertory (f, face, font_def, fontset);
+          ASET (elt, 1, make_number (font_idx));
+          if (font_idx < 0)
+            continue;
+        }
+
+      /* Now we have the opened font.  */
+      if (NILP (AREF (elt, 0)))
+        {
+          /* But not yet made a realized face that uses this font.  */
+          int face_id = lookup_non_ascii_face (f, font_idx, face);
+
+          ASET (elt, 0, make_number (face_id));
+        }
+
+      /* Ok, this face can display C.  */
+      return XINT (AREF (elt, 0));
+    }
+
+ font_not_found:
+  /* We have tried all the fonts for C, but none of them can be opened
+     nor can display C.  */
+  if (NILP (FONTSET_NOFONT_FACE (fontset)))
+    {
+      int face_id;
+
+      if (! face)
+        return -1;
+      face_id = lookup_non_ascii_face (f, -1, face);
+      FONTSET_NOFONT_FACE (fontset) = make_number (face_id);
+    }
+  return XINT (FONTSET_NOFONT_FACE (fontset));
 }
 
 
@@ -341,6 +629,7 @@ make_fontset (frame, name, base)
 
   if (id + 1 == size)
     {
+      /* We must grow Vfontset_table.  */
       Lisp_Object tem;
       int i;
 
@@ -371,9 +660,9 @@ make_fontset (frame, name, base)
 
 
 
-/********** INTERFACES TO xfaces.c and dispextern.h **********/
+/********** INTERFACES TO xfaces.c, xfns.c, and dispextern.h **********/
 
-/* Return name of the fontset with ID.  */
+/* Return the name of the fontset who has ID.  */
 
 Lisp_Object
 fontset_name (id)
@@ -386,16 +675,19 @@ fontset_name (id)
 }
 
 
-/* Return ASCII font name of the fontset with ID.  */
+/* Return the ASCII font name of the fontset who has ID.  */
 
 Lisp_Object
 fontset_ascii (id)
      int id;
 {
-  Lisp_Object fontset;
+  Lisp_Object fontset, elt;
 
   fontset= FONTSET_FROM_ID (id);
-  return FONTSET_ASCII (fontset);
+  elt = FONTSET_ASCII (fontset);
+  /* It is assured that ELT is always a string (i.e. fontname
+     pattern).  */
+  return elt;
 }
 
 
@@ -407,7 +699,7 @@ free_face_fontset (f, face)
      FRAME_PTR f;
      struct face *face;
 {
-  AREF (Vfontset_table, face->fontset) = Qnil;
+  ASET (Vfontset_table, face->fontset, Qnil);
   if (face->fontset < next_fontset_id)
     next_fontset_id = face->fontset;
 }
@@ -425,14 +717,13 @@ face_suitable_for_char_p (face, c)
   Lisp_Object fontset;
 
   fontset = FONTSET_FROM_ID (face->fontset);
-  return (face == fontset_face (fontset, c));
+  return (face->id == fontset_face (fontset, c, NULL));
 }
 
 
 /* Return ID of face suitable for displaying character C on frame F.
-   The selection of face is done based on the fontset of FACE.  FACE
-   must be reazlied for ASCII characters in advance.  Called from the
-   macro FACE_FOR_CHAR when C is not an ASCII character.  */
+   FACE must be reazlied for ASCII characters in advance.  Called from
+   the macro FACE_FOR_CHAR.  */
 
 int
 face_for_char (f, face, c)
@@ -441,19 +732,17 @@ face_for_char (f, face, c)
      int c;
 {
   Lisp_Object fontset;
-  struct face *new_face;
+  Lisp_Object elt, vec;
+  int font_idx;
+  int i;
+
+  if (ASCII_CHAR_P (c))
+    return face->ascii_face->id;
 
   xassert (fontset_id_valid_p (face->fontset));
   fontset = FONTSET_FROM_ID (face->fontset);
   xassert (!BASE_FONTSET_P (fontset));
-
-  new_face = fontset_face (fontset, c);
-  if (new_face)
-    return new_face->id;
-
-  /* No face is recorded for C in the fontset of FACE.  Make a new
-     realized face for C that has the same fontset.  */
-  return lookup_face (f, face->lface, c, face);
+  return fontset_face (fontset, c, face);
 }
 
 
@@ -463,9 +752,10 @@ face_for_char (f, face, c)
    Called from realize_x_face.  */
 
 int
-make_fontset_for_ascii_face (f, base_fontset_id)
+make_fontset_for_ascii_face (f, base_fontset_id, face)
      FRAME_PTR f;
      int base_fontset_id;
+     struct face *face;
 {
   Lisp_Object base_fontset, fontset, frame;
 
@@ -476,105 +766,69 @@ make_fontset_for_ascii_face (f, base_fontset_id)
       if (!BASE_FONTSET_P (base_fontset))
         base_fontset = FONTSET_BASE (base_fontset);
       xassert (BASE_FONTSET_P (base_fontset));
+      if (! BASE_FONTSET_P (base_fontset))
+        abort ();
     }
   else
     base_fontset = Vdefault_fontset;
 
   fontset = make_fontset (frame, Qnil, base_fontset);
+  {
+    Lisp_Object elt;
+
+    elt = FONTSET_REF (base_fontset, 0);
+    elt = Fmake_vector (make_number (3), AREF (elt, 0));
+    ASET (elt, 0, make_number (face->id));
+    ASET (elt, 1, make_number (face->font_info_id));
+    elt = Fcons (make_number (charset_ordered_list_tick),
+                 Fmake_vector (make_number (1), elt));
+    char_table_set_range (fontset, 0, 127, elt);
+  }
   return XINT (FONTSET_ID (fontset));
 }
 
 
-/* Return FONT-SPEC recorded in the fontset of FACE for character C.
-   If FACE is null, or the fontset doesn't contain information about
-   C, get the font name pattern from the default fontset.  Called from
-   choose_face_font.  */
-
-Lisp_Object
-fontset_font_pattern (f, face, c)
-     FRAME_PTR f;
-     struct face *face;
-     int c;
-{
-  Lisp_Object fontset, base, elt;
-  int id = face ? face->fontset : -1;
-
-  if (id >= 0)
-    {
-      fontset = FONTSET_FROM_ID (id);
-      xassert (!BASE_FONTSET_P (fontset));
-      base = FONTSET_BASE (fontset);
-    }
-  else
-    {
-      base = Vdefault_fontset;
-    }
-
-  FONTSET_REF (base, c, elt);
-  if (face && ! NILP (elt))
-    {
-      Lisp_Object slot;
-
-      slot = Fassoc (elt, FONTSET_FACE_ALIST (fontset));
-      if (CONSP (slot))
-        XSETCDR (slot, make_number (face->id));
-      FONTSET_FACE_ALIST (fontset)      
-        = Fcons (Fcons (elt, make_number (face->id)),
-                 FONTSET_FACE_ALIST (fontset));
-    }
-  return elt;
-}
-
-
 #if defined(WINDOWSNT) && defined (_MSC_VER)
 #pragma optimize("", off)
 #endif
 
 /* Load a font named FONTNAME on frame F.  Return a pointer to the
    struct font_info of the loaded font.  If loading fails, return
-   NULL.  */
+   NULL.  CHARSET_ID is an ID of charset to encode characters for this
+   font.  */
 
 struct font_info *
-fs_load_font (f, fontname)
+fs_load_font (f, fontname, charset_id)
      FRAME_PTR f;
      char *fontname;
+     int charset_id;
 {
-  Lisp_Object tail, elt;
   struct font_info *fontp;
 
   if (!fontname)
     /* No way to get fontname.  */
-    return 0;
+    return NULL;
 
   fontp = (*load_font_func) (f, fontname, 0);
   if (!fontp)
     return NULL;
 
   fontname = fontp->full_name;
-  /* Fill in members (charset, vertical_centering, encoding, etc) of
-     font_info structure that are not set by (*load_font_func).  */
-  for (tail = Vfont_encoding_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      elt = XCAR (tail);
-      if (STRINGP (XCAR (elt)) && CHARSETP (XCDR (elt))
-          && fast_c_string_match_ignore_case (XCAR (elt), fontname) >= 0)
-        {
-          fontp->charset = XFASTINT (CHARSET_SYMBOL_ID (XCDR (elt)));
-          break;
-        }
-    }
-  if (! CONSP (tail))
-    return NULL;
-
-  fontp->vertical_centering
-    = (STRINGP (Vvertical_centering_font_regexp)
-       && (fast_c_string_match_ignore_case
-           (Vvertical_centering_font_regexp, fontname) >= 0));
 
+  fontp->charset = charset_id;
+  fontp->vertical_centering = 0;
   fontp->font_encoder = NULL;
 
-  if (find_ccl_program_func)
-    (*find_ccl_program_func) (fontp);
+  if (charset_id != charset_ascii)
+    {
+      fontp->vertical_centering
+        = (STRINGP (Vvertical_centering_font_regexp)
+           && (fast_c_string_match_ignore_case
+               (Vvertical_centering_font_regexp, fontname) >= 0));
+
+      if (find_ccl_program_func)
+        (*find_ccl_program_func) (fontp);
+    }
 
   return fontp;
 }
@@ -584,6 +838,34 @@ fs_load_font (f, fontname)
 #endif
 
 
+/* Return ENCODING or a cons(ENCODING REPERTORY) of the font FONTNAME.
+   ENCODING is a charset symbol that specifies the encoding of the
+   font.  REPERTORY is a charset symbol or nil.  */
+
+
+static Lisp_Object
+find_font_encoding (fontname)
+     char *fontname;
+{
+  Lisp_Object tail, elt;
+
+  for (tail = Vfont_encoding_alist; CONSP (tail); tail = XCDR (tail))
+    {
+      elt = XCAR (tail);
+      if (CONSP (elt)
+          && STRINGP (XCAR (elt))
+          && fast_c_string_match_ignore_case (XCAR (elt), fontname) >= 0
+          && (SYMBOLP (XCDR (elt))
+              ? CHARSETP (XCDR (elt))
+              : CONSP (XCDR (elt)) && CHARSETP (XCAR (XCDR (elt)))))
+        return (XCDR (elt));
+    }
+  /* We don't know the encoding of this font.  Let's assume Unicode
+     encoding.  */
+  return Qunicode;
+}
+
+
 /* Cache data used by fontset_pattern_regexp.  The car part is a
    pattern string containing at least one wild card, the cdr part is
    the corresponding regular expression.  */
@@ -738,7 +1020,7 @@ list_fontsets (f, pattern, size)
         continue;
       name = XSTRING (FONTSET_NAME (fontset))->data;
 
-      if (!NILP (regexp)
+      if (STRINGP (regexp)
           ? (fast_c_string_match_ignore_case (regexp, name) < 0)
           : strcmp (XSTRING (pattern)->data, name))
         continue;
@@ -811,84 +1093,183 @@ check_fontset_name (name)
   return FONTSET_FROM_ID (id);
 }
 
-DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 4, 0,
-       doc: /* Modify fontset NAME to use FONT-SPEC for characters of CHARSETS.
+static void
+accumulate_script_ranges (arg, range, val)
+     Lisp_Object arg, range, val;
+{
+  if (EQ (XCAR (arg), val))
+    {
+      if (CONSP (range))
+        XSETCDR (arg, Fcons (Fcons (XCAR (range), XCDR (range)), XCDR (arg)));
+      else
+        XSETCDR (arg, Fcons (Fcons (range, range), XCDR (arg)));
+    }
+}
+
+
+DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 5, 0,
+       doc: /* 
+Modify fontset NAME to use FONT-SPEC for CHARACTER.
+
+CHARACTER may be a cons; (FROM . TO), where FROM and TO are
+characters.  In that case, use FONT-SPEC for all characters in the
+range FROM and TO (inclusive).
 
-CHARSET may be a cons; (FROM . TO), where FROM and TO are characters.
-In that case, use FONT-SPEC for all characters in the range FROM and
-TO (inclusive).
+CHARACTER may be a script name symbol.  In that case, use FONT-SPEC
+for all characters that belong to the script.
 
-FONT-SPEC is be a vector; [ FAMILY WEIGHT SLANT WIDTH ADSTYLE REGISTRY ]
+CHARACTER may be a charset who has :code-offset attribute and the
+attribute value is greater than the maximum Unicode character
+\(#x10FFFF).  In that case, use FONT-SPEC for all characters in the
+charset.
+
+FONT-SPEC is a vector; [ FAMILY WEIGHT SLANT ADSTYLE REGISTRY ].
+See the documentation of `set-face-attribute' for the detail of
+these vector elements.
 
-FONT-SPEC may be a cons; (FAMILY . REGISTRY), where FAMILY is a family
-name of a font, REGSITRY is a registry name of a font.
+FONT-SPEC may be a cons; (FAMILY . REGISTRY).
 
-FONT-SPEC may be a font name string.  */)
-     (name, charset, font_spec, frame)
-     Lisp_Object name, charset, font_spec, frame;
+FONT-SPEC may be a font name string.
+
+Optional 4th argument FRAME, if non-nil, is a frame.  This argument is
+kept for backward compatibility and has no meaning.
+
+Optional 5th argument ADD, if non-nil, specifies how to add FONT-SPEC
+to the font specifications for RANGE previously set.  If it is
+`prepend', FONT-SPEC is prepended.  If it is `append', FONT-SPEC is
+appended.  By default, FONT-SPEC overrides the previous settings.  */)
+     (name, character, font_spec, frame, add)
+     Lisp_Object name, character, font_spec, frame, add;
 {
   Lisp_Object fontset;
-  Lisp_Object family, registry;
+  int i;
+  Lisp_Object font_def, registry;
+  Lisp_Object val, encoding, repertory;
+  Lisp_Object range_list;
 
   fontset = check_fontset_name (name);
 
+  /* The arg FRAME is kept for backward compatibility.  We only check
+     the validity.  */
+  if (!NILP (frame))
+    CHECK_LIVE_FRAME (frame);
+
   if (VECTORP (font_spec))
     {
-      int i;
-      Lisp_Object val;
+      int j;
+
+      if (ASIZE (font_spec) != 6)
+        args_out_of_range (make_number (6),
+                           make_number (ASIZE (font_spec)));
 
       font_spec = Fcopy_sequence (font_spec);
-      for (i = 0; i < 5; i++)
-        {
-          val = Faref (font_spec, make_number (i));
-          if (! NILP (val))
-            {
-              CHECK_STRING (val);
-              ASET (font_spec, i, Fdowncase (val));
-            }
-        }
-      val = Faref (font_spec, make_number (5));
-      CHECK_STRING (val);
-      ASET (font_spec, 5, Fdowncase (val));
+      for (j = 0; j < 5; j++)
+        if (! NILP (AREF (font_spec, j)))
+          {
+            CHECK_STRING (AREF (font_spec, j));
+            ASET (font_spec, j, Fdowncase (AREF (font_spec, j)));
+          }
+      /* REGISTRY should not be omitted.  */
+      CHECK_STRING (AREF (font_spec, 5));
+      registry = Fdowncase (AREF (font_spec, 5));
+      ASET (font_spec, 5, registry);
+
     }
-  else if (STRINGP (font_spec))
-    font_spec = Fdowncase (font_spec);
   else if (CONSP (font_spec))
     {
-      CHECK_CONS (font_spec);
+      Lisp_Object family;
+
       family = XCAR (font_spec);
       registry = XCDR (font_spec);
-      font_spec = Fmake_vector (make_number (6), Qnil);
-      if (!NILP (family))
+
+      if (! NILP (family))
         {
           CHECK_STRING (family);
-          ASET (font_spec, 0, Fdowncase (family));
+          family = Fdowncase (family);
         }
       CHECK_STRING (registry);
-      ASET (font_spec, 5, Fdowncase (registry));
+      registry = Fdowncase (registry);
+      font_spec = Fmake_vector (make_number (6), Qnil);
+      ASET (font_spec, 0, family);
+      ASET (font_spec, 5, registry);
     }
-
-  if (SYMBOLP (charset))
+  else
     {
-      CHECK_CHARSET (charset);
+      CHECK_STRING (font_spec);
+      font_spec = Fdowncase (font_spec);
+      registry = font_name_registry (font_spec);
+      if (NILP (registry))
+        error ("No XLFD: %s", XSTRING (font_spec)->data);
     }
+
+  if (STRINGP (font_spec))
+    encoding = find_font_encoding ((char *) XSTRING (font_spec)->data);
   else
+    encoding = find_font_encoding ((char *) XSTRING (registry)->data);
+  if (SYMBOLP (encoding))
+    encoding = repertory = CHARSET_SYMBOL_ID (encoding);
+  else
+    {
+      repertory = XCDR (encoding);
+      encoding = CHARSET_SYMBOL_ID (XCAR (encoding));
+    }
+  font_def = Fmake_vector (make_number (3), font_spec);
+  ASET (font_def, 1, encoding);
+  ASET (font_def, 2, repertory);
+
+  if (CHARACTERP (character))
+    range_list = Fcons (Fcons (character, character), Qnil);
+  else if (CONSP (character))
     {
       Lisp_Object from, to;
 
-      /* CHARSET should be (FROM . TO).  */
-      from = Fcar (charset);
-      to = Fcdr (charset);
+      from = Fcar (character);
+      to = Fcdr (character);
       CHECK_CHARACTER (from);
       CHECK_CHARACTER (to);
+      range_list = Fcons (character, Qnil);
     }
+  else
+    {
+      Lisp_Object script_list;
+      Lisp_Object val;
 
-  /* The arg FRAME is kept for backward compatibility.  We only check
-     the validity.  */
-  if (!NILP (frame))
-    CHECK_LIVE_FRAME (frame);
+      CHECK_SYMBOL (character);
+      range_list = Qnil;
+      script_list = XCHAR_TABLE (Vchar_script_table)->extras[0];
+      if (! NILP (Fmemq (character, script_list)))
+        {
+          val = Fcons (character, Qnil);
+          map_char_table (accumulate_script_ranges, Qnil, Vchar_script_table,
+                          val, 0, NULL);
+          range_list = XCDR (val); 
+          if (EQ (character, Qascii))
+            {
+              if (! STRINGP (font_spec))
+                font_spec = generate_ascii_font_name (FONTSET_NAME (fontset),
+                                                      font_spec);
+              FONTSET_ASCII (fontset) = font_spec;
+            }
+        }
+      else if (CHARSETP (character))
+        {
+          struct charset *charset;
+
+          CHECK_CHARSET_GET_CHARSET (character, charset);
+          if (CHARSET_METHOD (charset) == CHARSET_METHOD_OFFSET)
+            range_list
+              = Fcons (Fcons (make_number (CHARSET_MIN_CHAR (charset)),
+                              make_number (CHARSET_MAX_CHAR (charset))),
+                       range_list);
+        }
 
-  FONTSET_SET (fontset, charset, font_spec);
+      if (NILP (range_list))
+        error ("Invalid script or charset name: %s",
+               XSYMBOL (character)->name->data);
+    }
+
+  for (; CONSP (range_list); range_list = XCDR (range_list))
+    FONTSET_ADD (fontset, XCAR (range_list), font_def, add);
 
   /* Free all realized fontsets whose base is FONTSET.  This way, the
      specified character(s) are surely redisplayed by a correct
@@ -902,51 +1283,50 @@ FONT-SPEC may be a font name string.  */)
 DEFUN ("new-fontset", Fnew_fontset, Snew_fontset, 2, 2, 0,
        doc: /* Create a new fontset NAME from font information in FONTLIST.
 
-FONTLIST is an alist of charsets vs corresponding font specifications.
-Each element of FONTLIST has the form (CHARSET . FONT-SPEC), where
-a character of CHARSET is displayed by a font that matches FONT-SPEC.
+FONTLIST is an alist of scripts vs the corresponding font specification list.
+Each element of FONTLIST has the form (SCRIPT FONT-SPEC ...), where
+a character of SCRIPT is displayed by a font that matches FONT-SPEC.
 
-FONT-SPEC is a vector [ FAMILY WEIGHT SLANT WIDTH ADSTYLE REGISTRY ], where
-FAMILY is a string specifying the font family,
-WEIGHT is a string specifying the weight of the font,
-SLANT is a string specifying the slant of the font,
-WIDTH is a string specifying the width of the font,
-ADSTYLE is a string specifying the adstyle of the font,
-REGISTRY is a string specifying the charset-registry of the font.
-
-See also the documentation of `set-face-attribute' for the detail of
-these vector elements.
+SCRIPT is a symbol that appears in the variable `script-alist'.
 
-FONT-SPEC may be a font name (string).  */)
+FONT-SPEC is a vector, a cons, or a string.  See the documentation of
+`set-fontset-font' for the meaning.  */)
   (name, fontlist)
      Lisp_Object name, fontlist;
 {
-  Lisp_Object fontset, ascii_font;
-  Lisp_Object tem, tail;
+  Lisp_Object fontset;
+  Lisp_Object val;
+  int id;
 
   CHECK_STRING (name);
   CHECK_LIST (fontlist);
 
-  name = Fdowncase (name);
-  tem = Fquery_fontset (name, Qnil);
-  if (! NILP (tem))
-    free_realized_fontsets (tem);
-
-  fontset = make_fontset (Qnil, name, Qnil);
-
-  /* Check the validity of FONTLIST.  */
-  ascii_font = Fcdr (Fassq (Qascii, fontlist));
-  if (NILP (ascii_font))
+  /* Check if an ASCII font is specified in FONTLIST.  */
+  val = Fcar (Fcdr (Fassq (Qascii, fontlist)));
+  if (NILP (val))
     error ("No ascii font specified");
-  if (! STRINGP (ascii_font))
-    ascii_font = generate_ascii_font (name, ascii_font);
 
-  fontlist = Fcopy_sequence (fontlist);
-  for (tail = fontlist; ! NILP (tail); tail = Fcdr (tail))
-    Fset_fontset_font (name, Fcar (Fcar (tail)), Fcdr (Fcar (tail)), Qnil);
-
-  FONTSET_ASCII (fontset) = ascii_font;
+  id = fs_query_fontset (name, 0);
+  if (id < 0)
+    fontset = make_fontset (Qnil, Fdowncase (name), Qnil);
+  else
+    {
+      fontset = FONTSET_FROM_ID (id);;
+      free_realized_fontsets (fontset);
+      Fset_char_table_range (fontset, Qt, Qnil);
+    }
 
+  for (; ! NILP (fontlist); fontlist = Fcdr (fontlist))
+    {
+      Lisp_Object elt, script;
+
+      elt = Fcar (fontlist);
+      script = Fcar (elt);
+      elt = Fcdr (elt);
+      Fset_fontset_font (name, script, Fcar (elt), Qnil, Qnil);
+      for (elt = Fcdr (elt); ! NILP (elt); elt = Fcdr (elt))
+        Fset_fontset_font (name, script, XCAR (elt), Qnil, Qappend);
+    }
   return name;
 }
 
@@ -1051,171 +1431,109 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 1, 0,
 }
 
 
-#if 0                           /* unused */
-/* Called from Ffontset_info via map_char_table on each leaf of
-   fontset.  ARG is a list (LAST FONT-INFO ...), where LAST is `(last
-   ARG)' and FONT-INFOs have this form:
-        (CHAR FONT-SPEC) or ((FROM . TO) FONT-SPEC)
-   The current leaf is indexed by CHARACTER and has value ELT.  This
-   function add the information of the current leaf to ARG by
-   appending a new element or modifying the last element..  */
+DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
+       doc: /* Return information about a fontset FONTSET on frame FRAME.
+The value is a char-table of which elements has this form.
 
-static void
-accumulate_font_info (arg, character, elt)
-     Lisp_Object arg, character, elt;
-{
-  Lisp_Object last, last_char, last_elt;
+    ((FONT-PATTERN OPENED-FONT ...) ...)
 
-  if (!CONSP (elt) && !SINGLE_BYTE_CHAR_P (XINT (character)))
-    FONTSET_REF (Vdefault_fontset, XINT (character), elt);
-  if (!CONSP (elt))
-    return;
-  last = XCAR (arg);
-  last_char = XCAR (XCAR (last));
-  last_elt = XCAR (XCDR (XCAR (last)));
-  elt = XCDR (elt);
-  if (!NILP (Fequal (elt, last_elt)))
-    {
-      struct charset *this_charset = CHAR_CHARSET (XINT (character));
+FONT-PATTERN is a vector:
 
-      if (CONSP (last_char))    /* LAST_CHAR == (FROM . TO)  */
-        {
-          if (this_charset == CHAR_CHARSET (XINT (XCAR (last_char))))
-            {
-              XSETCDR (last_char, character);
-              return;
-            }
-        }
-      else if (XINT (last_char) == XINT (character))
-        return;
-      else if (this_charset == CHAR_CHARSET (XINT (last_char)))
-        {
-          XSETCAR (XCAR (last), Fcons (last_char, character));
-          return;
-        }
-    }
-  XSETCDR (last, Fcons (Fcons (character, Fcons (elt, Qnil)), Qnil));
-  XSETCAR (arg, XCDR (last));
-}
-#endif /* 0 */
+        [ FAMILY WEIGHT SLANT SWIDTH ADSTYLE REGISTRY ]
 
-DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
-       doc: /* Return information about a fontset named NAME on frame FRAME.
-The value is a vector:
-  [ SIZE HEIGHT ((CHARSET-OR-RANGE FONT-SPEC OPENED ...) ...) ],
-where,
-  SIZE is the maximum bound width of ASCII font in the fontset,
-  HEIGHT is the maximum bound height of ASCII font in the fontset,
-  CHARSET-OR-RANGE is a charset or a cons of two characters specifying
-    the range of characters.
-  FONT-SPEC is a fontname pattern string or a vector
-    [ FAMILY WEIGHT SLANT WIDTH ADSTYLE REGISTRY ].
-    See the documentation of `new-fontset' for the meanings those elements.
-  OPENEDs are names of fonts actually opened.
-If the ASCII font is not yet opened, SIZE and HEIGHT are 0.
-If FRAME is omitted, it defaults to the currently selected frame.  */)
-     (name, frame)
-     Lisp_Object name, frame;
+or a string of font name pattern.
+
+OPENED-FONT is a name of a font actually opened.  */)
+     (fontset, frame)
+     Lisp_Object fontset, frame;
 {
-  Lisp_Object fontset;
   FRAME_PTR f;
-  Lisp_Object val, tail, elt;
+  Lisp_Object table, val, elt;
   Lisp_Object *realized;
   struct font_info *fontp = NULL;
   int n_realized = 0;
-  int i;
+  int c, i, j;
 
   (*check_window_system_func) ();
 
-  fontset = check_fontset_name (name);
+  fontset = check_fontset_name (fontset);
 
   if (NILP (frame))
     frame = selected_frame;
   CHECK_LIVE_FRAME (frame);
   f = XFRAME (frame);
 
-  /* Recode realized fontsets whose base is FONTSET in the table
-     `realized'.  */
+  /* Recode fontsets realized on FRAME from the base fontset FONTSET
+     in the table `realized'.  */
   realized = (Lisp_Object *) alloca (sizeof (Lisp_Object)
                                      * ASIZE (Vfontset_table));
   for (i = 0; i < ASIZE (Vfontset_table); i++)
     {
       elt = FONTSET_FROM_ID (i);
       if (!NILP (elt)
-          && EQ (FONTSET_BASE (elt), fontset))
+          && EQ (FONTSET_BASE (elt), fontset)
+          && EQ (FONTSET_FRAME (elt), frame))
         realized[n_realized++] = elt;
     }
 
-  /* Accumulate information of the fontset in VAL.  The format is
-     (LAST FONT-INFO FONT-INFO ...), where FONT-INFO is (CHAR-OR-RANGE
-     FONT-SPEC).  See the comment for accumulate_font_info for the
-     detail.  */
-  val = Fcons (Fcons (Qascii, Fcons (FONTSET_ASCII (fontset), Qnil)), Qnil);
-  val = Fcons (val, val);
-  for (i = 128; i <= MAX_CHAR; )
+
+  table = Fmake_char_table (Qnil, Qnil);
+  /* Accumulate information of the fontset in TABLE.  The format of
+     each element is ((FONT-SPEC OPENED-FONT ...) ...).  */
+  for (c = 0; c <= MAX_CHAR; )
     {
-      Lisp_Object elt;
       int from, to;
 
-      elt = char_table_ref_and_range (fontset, i, &from, &to);
-      if (! NILP (elt))
+      val = FONTSET_REF_AND_RANGE (fontset, c, from, to);
+      if (VECTORP (val))
         {
-          elt = Fcons (Fcons (make_number (from), make_number (to)),
-                       Fcons (elt, Qnil));
-          XSETCDR (XCAR (val), Fcons (elt, Qnil));
-          XSETCAR (val, XCDR (XCAR (val)));
-        }
-      i = to + 1;
-    }
-
-  for (tail = FONTSET_CHARSET_ALIST (fontset);
-       CONSP (tail); tail = XCDR (tail))
-    {
-      elt = XCAR (tail);
-      elt = Fcons ((INTEGERP (XCAR (elt))
-                    ? CHARSET_NAME (CHARSET_FROM_ID (XFASTINT (XCAR (elt))))
-                    : XCAR (elt)),
-                   Fcons (XCDR (elt), Qnil));
-      XSETCDR (XCAR (val), Fcons (elt, Qnil));
-      XSETCAR (val, XCDR (XCAR (val)));
-    }
+          Lisp_Object alist;
 
-  val = XCDR (val);
-
-  /* If fonts are opened for FONT-SPEC, append the names of the fonts to
-     FONT-SPEC.  */
-  for (tail = val; CONSP (tail); tail = XCDR (tail))
-    {
-      elt = XCAR (tail);
-      for (i = 0; i < n_realized; i++)
-        {
-          Lisp_Object face_list, fontname;
+          /* At first, set ALIST to ((FONT-SPEC) ...).  */
+          for (alist = Qnil, i = 0; i < ASIZE (val); i++)
+            alist = Fcons (Fcons (AREF (AREF (val, i), 0), Qnil), alist);
+          alist = Fnreverse (alist);
 
-          for (face_list = FONTSET_FACE_ALIST (realized[i]);
-               CONSP (face_list); face_list = XCDR (face_list))
+          /* Then store opend font names to cdr of each elements.  */
+          for (i = 0; i < n_realized; i++)
             {
-              int face_id = XINT (XCDR (XCAR (face_list)));
-              struct face *face = FACE_FROM_ID (f, face_id);
-
-              if (face->font && face->font_name)
-                {
-                  fontname = build_string (face->font_name);
-                  if (NILP (Fmember (fontname, XCDR (XCDR (elt)))))
-                    XSETCDR (XCDR (elt), Fcons (fontname, XCDR (XCDR (elt))));
-                }
+              val = FONTSET_REF (realized[i], c);
+              if (NILP (val))
+                continue;
+              val = XCDR (val);
+              /* Now VAL is [[FACE-ID FONT-INDEX FONT-DEF] ...].
+                 If a font of an element is already opened,
+                 FONT-INDEX of the element is integer.  */
+              for (j = 0; j < ASIZE (val); j++)
+                if (INTEGERP (AREF (AREF (val, j), 0)))
+                  {
+                    Lisp_Object font_idx;
+
+                    font_idx = AREF (AREF (val, j), 1);
+                    elt = Fassq (AREF (AREF (AREF (val, j), 2), 0), alist);
+                    if (CONSP (elt)
+                        && NILP (Fmemq (font_idx, XCDR(elt))))
+                      nconc2 (elt, Fcons (font_idx, Qnil));
+                  }
             }
+          for (val = alist; CONSP (val); val = XCDR (val))
+            for (elt = XCDR (XCAR (val)); CONSP (elt); elt = XCDR (elt))
+              {
+                struct font_info *font_info
+                  = (*get_font_info_func) (f, XINT (XCAR (elt)));
+                XSETCAR (elt, build_string (font_info->full_name));
+              }
+
+          /* Store ALIST in TABLE for characters C..TO.  */
+          char_table_set_range (table, c, to, alist);
         }
+      c = to + 1;
     }
 
-  elt = XCDR (XCDR (XCAR (val)));
-  if (CONSP (elt))
-    fontp = (*query_font_func) (f, XSTRING (XCAR (elt))->data);
-  val = Fmake_vector (make_number (3), val);
-  AREF (val, 0) = fontp ? make_number (fontp->size) : make_number (0);
-  AREF (val, 1) = fontp ? make_number (fontp->height) : make_number (0);
-  return val;
+  return table;
 }
 
+
 DEFUN ("fontset-font", Ffontset_font, Sfontset_font, 2, 2, 0,
        doc: /* Return a font name pattern for character CH in fontset NAME.
 If NAME is t, find a font name pattern in the default fontset.  */)
@@ -1229,8 +1547,8 @@ If NAME is t, find a font name pattern in the default fontset.  */)
 
   CHECK_CHARACTER (ch);
   c = XINT (ch);
-  FONTSET_REF (fontset, c, elt);
-  return elt;
+  elt = FONTSET_REF (fontset, c);
+  return Fcopy_sequence (elt);
 }
 
 DEFUN ("fontset-list", Ffontset_list, Sfontset_list, 0, 0, 0,
@@ -1259,10 +1577,12 @@ syms_of_fontset ()
     /* Window system initializer should have set proper functions.  */
     abort ();
 
-  Qfontset = intern ("fontset");
-  staticpro (&Qfontset);
+  DEFSYM (Qfontset, "fontset");
   Fput (Qfontset, Qchar_table_extra_slots, make_number (7));
 
+  DEFSYM (Qprepend, "prepend");
+  DEFSYM (Qappend, "append");
+
   Vcached_fontset_data = Qnil;
   staticpro (&Vcached_fontset_data);
 
@@ -1293,13 +1613,27 @@ syms_of_fontset ()
   next_fontset_id = 1;
 
   DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist,
-               doc: /* Alist of fontname patterns vs corresponding encoding info.
-Each element looks like (REGEXP . CHARSET), where CHARSET is an
-Emacs charset symbol.  */);
+               doc: /*
+Alist of fontname patterns vs the corresponding encoding and repertory info.
+Each element looks like (REGEXP . (ENCODING . REPERTORY)),
+where ENCODING is a charset or a char-table,
+and REPERTORY is a charset, a char-table, or nil.  
+
+ENCODING is for converting a character to a glyph code of the font.
+If ENCODING is a charset, encoding a character by the charset gives
+the corresponding glyph code.  If ENCODING is a char-table, looking up
+the table by a character gives the corresponding glyph code.
+
+REPERTORY specifies a repertory of characters supported by the font.
+If REPERTORY is a charset, all characters beloging to the charset are
+supported.  If REPERTORY is a char-table, all characters who have a
+non-nil value in the table are supported.  It REPERTORY is nil, Emacs
+gets the repertory information by an opened font and ENCODING.  */);
   Vfont_encoding_alist = Qnil;
 
   DEFVAR_LISP ("use-default-ascent", &Vuse_default_ascent,
-               doc: /* Char table of characters whose ascent values should be ignored.
+               doc: /*
+Char table of characters whose ascent values should be ignored.
 If an entry for a character is non-nil, the ascent value of the glyph
 is assumed to be what specified by _MULE_DEFAULT_ASCENT property of a font.
 
@@ -1308,7 +1642,8 @@ such a character is displayed on screen.  */);
   Vuse_default_ascent = Qnil;
 
   DEFVAR_LISP ("ignore-relative-composition", &Vignore_relative_composition,
-               doc: /* Char table of characters which is not composed relatively.
+               doc: /*
+Char table of characters which is not composed relatively.
 If an entry for a character is non-nil, a composition sequence
 which contains that character is displayed so that
 the glyph of that character is put without considering