(get_keyelt): Handle an indirect entry with meta char.

(describe_vector): Rewrite char-table handling.

(Fmake_keymap): Make a char-table.
(access_keymap, store_in_keymap): Likewise,
(describe_map, Fset_keymap_parent, Faccessible_keymaps): Likewise.
(Fwhere_is_internal, Fcopy_keymap): Handle a char-table.
(copy_keymap_1, accessible_keymaps_char_table): New subroutines.
(where_is_internal_1, where_is_internal_2): New functions.
(syms_of_keymap): Set up Qchar_table_extra_slots prop on Qkeymap.

1 files changed, 429 insertions, 241 deletions

diff --git a/src/keymap.c b/src/keymap.c
index 7ef50502ba9..35465ad8597 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -118,8 +118,7 @@ in case you use it as a menu with `x-popup-menu'.")
   else
     tail = Qnil;
   return Fcons (Qkeymap,
-		Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE), Qnil),
-		       tail));
+		Fcons (Fmake_char_table (Qkeymap, Qnil), tail));
 }
 
 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
@@ -338,6 +337,15 @@ PARENT should be nil or another keymap.")
 	  if (CONSP (XVECTOR (XCONS (list)->car)->contents[i]))
 	    fix_submap_inheritance (keymap, make_number (i),
 				    XVECTOR (XCONS (list)->car)->contents[i]);
+
+      if (CHAR_TABLE_P (XCONS (list)->car))
+	{
+	  Lisp_Object *indices
+	    = (Lisp_Object *) alloca (3 * sizeof (Lisp_Object));
+
+	  map_char_table (fix_submap_inheritance, Qnil, XCONS (list)->car,
+			  keymap, 0, indices);
+	}
     }
 
   return parent;
@@ -473,6 +481,18 @@ access_keymap (map, idx, t_ok, noinherit)
 		return val;
 	      }
 	  }
+	else if (CHAR_TABLE_P (binding))
+	  {
+	    if (NATNUMP (idx))
+	      {
+		val = Faref (binding, idx);
+		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+		  return Qnil;
+		if (CONSP (val))
+		  fix_submap_inheritance (map, idx, val);
+		return val;
+	      }
+	  }
 
 	QUIT;
       }
@@ -506,8 +526,22 @@ get_keyelt (object, autoload)
       map = get_keymap_1 (Fcar_safe (object), 0, autoload);
       tem = Fkeymapp (map);
       if (!NILP (tem))
-	object = access_keymap (map, Fcdr (object), 0, 0);
-      
+	{
+	  Lisp_Object key;
+	  key = Fcdr (object);
+	  if (INTEGERP (key) && (XINT (key) & meta_modifier))
+	    {
+	      object = access_keymap (map, make_number (meta_prefix_char),
+				      0, 0);
+	      map = get_keymap_1 (object, 0, autoload);
+	      object = access_keymap (map,
+				      make_number (XINT (key) & ~meta_modifier),
+				      0, 0);
+	    }
+	  else
+	    object = access_keymap (map, key, 0, 0);
+	}
+
       /* If the keymap contents looks like (STRING . DEFN),
 	 use DEFN.
 	 Keymap alist elements like (CHAR MENUSTRING . DEFN)
@@ -592,6 +626,15 @@ store_in_keymap (keymap, idx, def)
 	      }
 	    insertion_point = tail;
 	  }
+	else if (CHAR_TABLE_P (elt))
+	  {
+	    if (NATNUMP (idx))
+	      {
+		Faset (elt, idx, def);
+		return def;
+	      }
+	    insertion_point = tail;
+	  }
 	else if (CONSP (elt))
 	  {
 	    if (EQ (idx, XCONS (elt)->car))
@@ -623,6 +666,12 @@ store_in_keymap (keymap, idx, def)
   return def;
 }
 
+Lisp_Object
+copy_keymap_1 (chartable, idx, elt)
+     Lisp_Object chartable, idx, elt;
+{
+  Faset (chartable, idx, Fcopy_keymap (elt));
+}
 
 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
   "Return a copy of the keymap KEYMAP.\n\
@@ -643,7 +692,15 @@ is not copied.")
       Lisp_Object elt;
 
       elt = XCONS (tail)->car;
-      if (VECTORP (elt))
+      if (CHAR_TABLE_P (elt))
+	{
+	  Lisp_Object *indices
+	    = (Lisp_Object *) alloca (3 * sizeof (Lisp_Object));
+
+	  elt = Fcopy_sequence (elt);
+	  map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
+	}
+      else if (VECTORP (elt))
 	{
 	  int i;
 
@@ -653,8 +710,8 @@ is not copied.")
 	  for (i = 0; i < XVECTOR (elt)->size; i++)
 	    if (!SYMBOLP (XVECTOR (elt)->contents[i])
 		&& ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
-	      XVECTOR (elt)->contents[i] =
-		Fcopy_keymap (XVECTOR (elt)->contents[i]);
+	      XVECTOR (elt)->contents[i]
+		= Fcopy_keymap (XVECTOR (elt)->contents[i]);
 	}
       else if (CONSP (elt))
 	{
@@ -1268,6 +1325,8 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_
 
 /* Help functions for describing and documenting keymaps.		*/
 
+static Lisp_Object accessible_keymaps_char_table ();
+
 /* This function cannot GC.  */
 
 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
@@ -1358,7 +1417,16 @@ then the value includes only maps for prefixes that start with PREFIX.")
 
 	  QUIT;
 
-	  if (VECTORP (elt))
+	  if (CHAR_TABLE_P (elt))
+	    {
+	      Lisp_Object *indices
+		= (Lisp_Object *) alloca (3 * sizeof (Lisp_Object));
+
+	      map_char_table (accessible_keymaps_char_table, Qnil,
+			      elt, Fcons (maps, Fcons (tail, thisseq)),
+			      0, indices);
+	    }
+	  else if (VECTORP (elt))
 	    {
 	      register int i;
 
@@ -1404,7 +1472,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
 			}
 		    }
 		}
-	    }	    
+	    }
 	  else if (CONSP (elt))
 	    {
 	      register Lisp_Object cmd, tem, filter;
@@ -1481,6 +1549,35 @@ then the value includes only maps for prefixes that start with PREFIX.")
   return Fnreverse (good_maps);
 }
 
+static Lisp_Object
+accessible_keymaps_char_table (args, index, cmd)
+     Lisp_Object args, index, cmd;
+{
+  Lisp_Object tem;
+  Lisp_Object maps, tail, thisseq;
+
+  if (NILP (cmd))
+    return Qnil;
+
+  maps = XCONS (args)->car;
+  tail = XCONS (XCONS (args)->cdr)->car;
+  thisseq = XCONS (XCONS (args)->cdr)->cdr;
+
+  tem = Fkeymapp (cmd);
+  if (!NILP (tem))
+    {
+      cmd = get_keymap (cmd);
+      /* Ignore keymaps that are already added to maps.  */
+      tem = Frassq (cmd, maps);
+      if (NILP (tem))
+	{
+	  tem = append_key (thisseq, index);
+	  nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
+	}
+    }
+  return Qnil;
+}
+
 Lisp_Object Qsingle_key_description, Qkey_description;
 
 /* This function cannot GC.  */
@@ -1747,6 +1844,9 @@ ascii_sequence_p (seq)
 
 /* where-is - finding a command in a set of keymaps.			*/
 
+static Lisp_Object where_is_internal_1 ();
+static Lisp_Object where_is_internal_2 ();
+
 /* This function can GC if Flookup_key autoloads any keymaps.  */
 
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,
@@ -1769,7 +1869,7 @@ indirect definition itself.")
      Lisp_Object firstonly, noindirect;
 {
   Lisp_Object maps;
-  Lisp_Object found, sequence;
+  Lisp_Object found, sequences;
   int keymap_specified = !NILP (keymap);
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   /* 1 means ignore all menu bindings entirely.  */
@@ -1805,18 +1905,15 @@ indirect definition itself.")
 	}
     }
 
-  GCPRO5 (definition, keymap, maps, found, sequence);
+  GCPRO5 (definition, keymap, maps, found, sequences);
   found = Qnil;
-  sequence = Qnil;
+  sequences = Qnil;
 
   for (; !NILP (maps); maps = Fcdr (maps))
     {
       /* Key sequence to reach map, and the map that it reaches */
       register Lisp_Object this, map;
 
-      /* If Fcar (map) is a VECTOR, the current element within that vector.  */
-      int i = 0;
-
       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
 	 [M-CHAR] sequences, check if last character of the sequence
 	 is the meta-prefix char.  */
@@ -1841,9 +1938,11 @@ indirect definition itself.")
 	     For this reason, if Fcar (map) is a vector, we don't
 	     advance map to the next element until i indicates that we
 	     have finished off the vector.  */
-	  
 	  Lisp_Object elt, key, binding;
 	  elt = XCONS (map)->car;
+	  map = XCONS (map)->cdr;
+
+	  sequences = Qnil;
 
 	  QUIT;
 
@@ -1851,130 +1950,70 @@ indirect definition itself.")
 	     advance map and i to the next binding.  */
 	  if (VECTORP (elt))
 	    {
+	      Lisp_Object sequence;
+	      int i;
 	      /* In a vector, look at each element.  */
-	      binding = XVECTOR (elt)->contents[i];
-	      XSETFASTINT (key, i);
-	      i++;
-
-	      /* If we've just finished scanning a vector, advance map
-		 to the next element, and reset i in anticipation of the
-		 next vector we may find.  */
-	      if (i >= XVECTOR (elt)->size)
+	      for (i = 0; i < XVECTOR (elt)->size; i++)
 		{
-		  map = XCONS (map)->cdr;
-		  i = 0;
+		  binding = XVECTOR (elt)->contents[i];
+		  XSETFASTINT (key, i);
+		  sequence = where_is_internal_1 (binding, key, definition,
+						  noindirect, keymap, this,
+						  last, nomenus, last_is_meta);
+		  if (!NILP (sequence))
+		    sequences = Fcons (sequence, sequences);
 		}
 	    }
-	  else if (CONSP (elt))
+	  else if (CHAR_TABLE_P (elt))
 	    {
-	      key = Fcar (Fcar (map));
-	      binding = Fcdr (Fcar (map));
-
-	      map = XCONS (map)->cdr;
+	      Lisp_Object *indices
+		= (Lisp_Object *) alloca (3 * sizeof (Lisp_Object));
+	      Lisp_Object args;
+	      args = Fcons (Fcons (Fcons (definition, noindirect),
+				   Fcons (keymap, Qnil)),
+			    Fcons (Fcons (this, last),
+				   Fcons (make_number (nomenus),
+					  make_number (last_is_meta))));
+
+	      map_char_table (where_is_internal_2, Qnil, elt, args,
+			      0, indices);
+	      sequences = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
 	    }
-	  else
-	    /* We want to ignore keymap elements that are neither
-	       vectors nor conses.  */
+	  else if (CONSP (elt))
 	    {
-	      map = XCONS (map)->cdr;
-	      continue;
-	    }
+	      Lisp_Object sequence;
 
-	  /* Search through indirections unless that's not wanted.  */
-	  if (NILP (noindirect))
-	    {
-	      if (nomenus)
-		{
-		  while (1)
-		    {
-		      Lisp_Object map, tem;
-		      /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
-		      map = get_keymap_1 (Fcar_safe (definition), 0, 0);
-		      tem = Fkeymapp (map);
-		      if (!NILP (tem))
-			definition = access_keymap (map, Fcdr (definition), 0, 0);
-		      else
-			break;
-		    }
-		  /* If the contents are (STRING ...), reject.  */
-		  if (CONSP (definition)
-		      && STRINGP (XCONS (definition)->car))
-		    continue;
-		}
-	      else
-		binding = get_keyelt (binding, 0);
-	    }
-
-	  /* End this iteration if this element does not match
-	     the target.  */
-
-	  if (CONSP (definition))
-	    {
-	      Lisp_Object tem;
-	      tem = Fequal (binding, definition);
-	      if (NILP (tem))
-		continue;
-	    }
-	  else
-	    if (!EQ (binding, definition))
-	      continue;
+	      key = XCONS (elt)->car;
+	      binding = XCONS (elt)->cdr;
 
-	  /* We have found a match.
-	     Construct the key sequence where we found it.  */
-	  if (INTEGERP (key) && last_is_meta)
-	    {
-	      sequence = Fcopy_sequence (this);
-	      Faset (sequence, last, make_number (XINT (key) | meta_modifier));
+	      sequence = where_is_internal_1 (binding, key, definition,
+					      noindirect, keymap, this,
+					      last, nomenus, last_is_meta);
+	      if (!NILP (sequence))
+		sequences = Fcons (sequence, sequences);
 	    }
-	  else
-	    sequence = append_key (this, key);
-
-	  /* Verify that this key binding is not shadowed by another
-	     binding for the same key, before we say it exists.
 
-	     Mechanism: look for local definition of this key and if
-	     it is defined and does not match what we found then
-	     ignore this key.
 
-	     Either nil or number as value from Flookup_key
-	     means undefined.  */
-	  if (keymap_specified)
+	  for (; ! NILP (sequences); sequences = XCONS (sequences)->cdr)
 	    {
-	      binding = Flookup_key (keymap, sequence, Qnil);
-	      if (!NILP (binding) && !INTEGERP (binding))
-		{
-		  if (CONSP (definition))
-		    {
-		      Lisp_Object tem;
-		      tem = Fequal (binding, definition);
-		      if (NILP (tem))
-			continue;
-		    }
-		  else
-		    if (!EQ (binding, definition))
-		      continue;
-		}
+	      Lisp_Object sequence;
+
+	      sequence = XCONS (sequences)->car;
+
+	      /* It is a true unshadowed match.  Record it, unless it's already
+		 been seen (as could happen when inheriting keymaps).  */
+	      if (NILP (Fmember (sequence, found)))
+		found = Fcons (sequence, found);
+
+	      /* If firstonly is Qnon_ascii, then we can return the first
+		 binding we find.  If firstonly is not Qnon_ascii but not
+		 nil, then we should return the first ascii-only binding
+		 we find.  */
+	      if (EQ (firstonly, Qnon_ascii))
+		RETURN_UNGCPRO (sequence);
+	      else if (! NILP (firstonly) && ascii_sequence_p (sequence))
+		RETURN_UNGCPRO (sequence);
 	    }
-	  else
-	    {
-	      binding = Fkey_binding (sequence, Qnil);
-	      if (!EQ (binding, definition))
-		continue;
-	    }
-
-	  /* It is a true unshadowed match.  Record it, unless it's already
-	     been seen (as could happen when inheriting keymaps).  */
-	  if (NILP (Fmember (sequence, found)))
-	    found = Fcons (sequence, found);
-
-	  /* If firstonly is Qnon_ascii, then we can return the first
-	     binding we find.  If firstonly is not Qnon_ascii but not
-	     nil, then we should return the first ascii-only binding
-	     we find.  */
-	  if (EQ (firstonly, Qnon_ascii))
-	    RETURN_UNGCPRO (sequence);
-	  else if (! NILP (firstonly) && ascii_sequence_p (sequence))
-	    RETURN_UNGCPRO (sequence);
 	}
     }
 
@@ -1990,6 +2029,135 @@ indirect definition itself.")
     
   return found;
 }
+
+/* This is the function that Fwhere_is_internal calls using map_char_table.
+   ARGS has the form
+   (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
+    .
+    ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
+   Since map_char_table doesn't really use the return value from this function,
+   we the result append to RESULT, the slot in ARGS.  */
+
+static Lisp_Object
+where_is_internal_2 (args, key, binding)
+     Lisp_Object args, key, binding;
+{
+  Lisp_Object definition, noindirect, keymap, this, last;
+  Lisp_Object result, sequence;
+  int nomenus, last_is_meta;
+
+  result = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
+  definition = XCONS (XCONS (XCONS (args)->car)->car)->car;
+  noindirect = XCONS (XCONS (XCONS (args)->car)->car)->cdr;
+  keymap = XCONS (XCONS (XCONS (args)->car)->cdr)->car;
+  this = XCONS (XCONS (XCONS (args)->cdr)->car)->car;
+  last = XCONS (XCONS (XCONS (args)->cdr)->car)->cdr;
+  nomenus = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->car);
+  last_is_meta = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->cdr);
+
+  sequence = where_is_internal_1 (binding, key, definition, noindirect, keymap,
+				  this, last, nomenus, last_is_meta);
+
+  if (!NILP (sequence))
+    XCONS (XCONS (XCONS (args)->car)->cdr)->cdr
+      = Fcons (sequence, result);
+
+  return Qnil;
+}
+
+static Lisp_Object
+where_is_internal_1 (binding, key, definition, noindirect, keymap, this, last,
+		     nomenus, last_is_meta)
+     Lisp_Object binding, key, definition, noindirect, keymap, this, last;
+     int nomenus, last_is_meta;
+{
+  Lisp_Object sequence;
+  int keymap_specified = !NILP (keymap);
+
+  /* Search through indirections unless that's not wanted.  */
+  if (NILP (noindirect))
+    {
+      if (nomenus)
+	{
+	  while (1)
+	    {
+	      Lisp_Object map, tem;
+	      /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
+	      map = get_keymap_1 (Fcar_safe (definition), 0, 0);
+	      tem = Fkeymapp (map);
+	      if (!NILP (tem))
+		definition = access_keymap (map, Fcdr (definition), 0, 0);
+	      else
+		break;
+	    }
+	  /* If the contents are (STRING ...), reject.  */
+	  if (CONSP (definition)
+	      && STRINGP (XCONS (definition)->car))
+	    return Qnil;
+	}
+      else
+	binding = get_keyelt (binding, 0);
+    }
+
+  /* End this iteration if this element does not match
+     the target.  */
+
+  if (CONSP (definition))
+    {
+      Lisp_Object tem;
+      tem = Fequal (binding, definition);
+      if (NILP (tem))
+	return Qnil;
+    }
+  else
+    if (!EQ (binding, definition))
+      return Qnil;
+
+  /* We have found a match.
+     Construct the key sequence where we found it.  */
+  if (INTEGERP (key) && last_is_meta)
+    {
+      sequence = Fcopy_sequence (this);
+      Faset (sequence, last, make_number (XINT (key) | meta_modifier));
+    }
+  else
+    sequence = append_key (this, key);
+
+  /* Verify that this key binding is not shadowed by another
+     binding for the same key, before we say it exists.
+
+     Mechanism: look for local definition of this key and if
+     it is defined and does not match what we found then
+     ignore this key.
+
+     Either nil or number as value from Flookup_key
+     means undefined.  */
+  if (keymap_specified)
+    {
+      binding = Flookup_key (keymap, sequence, Qnil);
+      if (!NILP (binding) && !INTEGERP (binding))
+	{
+	  if (CONSP (definition))
+	    {
+	      Lisp_Object tem;
+	      tem = Fequal (binding, definition);
+	      if (NILP (tem))
+		return Qnil;
+	    }
+	  else
+	    if (!EQ (binding, definition))
+	      return Qnil;
+	}
+    }
+  else
+    {
+      binding = Fkey_binding (sequence, Qnil);
+      if (!EQ (binding, definition))
+	return Qnil;
+    }
+
+  return sequence;
+}
 
 /* describe-bindings - summarizing all the bindings in a set of keymaps.  */
 
@@ -2403,9 +2571,11 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
     {
       QUIT;
 
-      if (VECTORP (XCONS (tail)->car))
+      if (VECTORP (XCONS (tail)->car)
+	  || CHAR_TABLE_P (XCONS (tail)->car))
 	describe_vector (XCONS (tail)->car,
-			 elt_prefix, elt_describer, partial, shadow, map);
+			 elt_prefix, elt_describer, partial, shadow, map,
+			 (int *)0, 0);
       else if (CONSP (XCONS (tail)->car))
 	{
 	  event = XCONS (XCONS (tail)->car)->car;
@@ -2494,7 +2664,8 @@ This is text showing the elements of vector matched against indices.")
 
   specbind (Qstandard_output, Fcurrent_buffer ());
   CHECK_VECTOR_OR_CHAR_TABLE (vector, 0);
-  describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil, Qnil);
+  describe_vector (vector, Qnil, describe_vector_princ, 0,
+		   Qnil, Qnil, (int *)0, 0);
 
   return unbind_to (count, Qnil);
 }
@@ -2504,7 +2675,8 @@ This is text showing the elements of vector matched against indices.")
    in VECTOR.
 
    ELT_PREFIX describes what "comes before" the keys or indices defined
-   by this vector.
+   by this vector.  This is a human-readable string whose size
+   is not necessarily related to the situation.
 
    If the vector is in a keymap, ELT_PREFIX is a prefix key which
    leads to this keymap.
@@ -2522,38 +2694,43 @@ This is text showing the elements of vector matched against indices.")
 
    ENTIRE_MAP is the keymap in which this vector appears.
    If the definition in effect in the whole map does not match
-   the one in this vector, we ignore this one.  */
+   the one in this vector, we ignore this one.
+
+   When describing a sub-char-table, INDICES is a list of
+   indices at higher levels in this char-table,
+   and CHAR_TABLE_DEPTH says how many levels down we have gone.  */
 
 describe_vector (vector, elt_prefix, elt_describer,
-		 partial, shadow, entire_map)
+		 partial, shadow, entire_map,
+		 indices, char_table_depth)
      register Lisp_Object vector;
      Lisp_Object elt_prefix;
      int (*elt_describer) ();
      int partial;
      Lisp_Object shadow;
      Lisp_Object entire_map;
+     int *indices;
+     int char_table_depth;
 {
-  Lisp_Object dummy;
   Lisp_Object definition;
   Lisp_Object tem2;
   register int i;
   Lisp_Object suppress;
   Lisp_Object kludge;
-  Lisp_Object chartable_kludge;
   int first = 1;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   /* Range of elements to be handled.  */
   int from, to;
-  /* The current depth of VECTOR if it is char-table.  */
-  int this_level;
   /* Flag to tell if we should handle multibyte characters.  */
   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
-  /* Array of indices to access each level of char-table.
-     The elements are charset, code1, and code2.  */
-  int idx[3];
   /* A flag to tell if a leaf in this level of char-table is not a
      generic character (i.e. a complete multibyte character).  */
   int complete_char;
+  int character;
+  int starting_i;
+
+  if (indices == 0)
+    indices = (Lisp_Object *) alloca (3 * sizeof (Lisp_Object));
 
   definition = Qnil;
 
@@ -2561,57 +2738,45 @@ describe_vector (vector, elt_prefix, elt_describer,
      that is done once per vector element, we don't want to cons up a
      fresh vector every time.  */
   kludge = Fmake_vector (make_number (1), Qnil);
-  GCPRO4 (elt_prefix, definition, kludge, chartable_kludge);
+  GCPRO3 (elt_prefix, definition, kludge);
 
   if (partial)
     suppress = intern ("suppress-keymap");
 
   if (CHAR_TABLE_P (vector))
     {
-      /* Prepare for handling a nested char-table.  */
-      if (NILP (elt_prefix))
+      if (char_table_depth == 0)
 	{
 	  /* VECTOR is a top level char-table.  */
-	  this_level = 0;
-	  complete_char = 0;
+	  complete_char = 1;
 	  from = 0;
 	  to = CHAR_TABLE_ORDINARY_SLOTS;
 	}
       else
 	{
 	  /* VECTOR is a sub char-table.  */
-	  this_level = XVECTOR (elt_prefix)->size;
-	  if (this_level >= 3)
-	    /* A char-table is not that deep.  */
+	  if (char_table_depth >= 3)
+	    /* A char-table is never that deep.  */
 	    error ("Too deep char table");
 
-	  /* For multibyte characters, the top level index for
-             charsets starts from 256.  */
-	  idx[0] = XINT (XVECTOR (elt_prefix)->contents[0]) - 128;
-	  for (i = 1; i < this_level; i++)
-	    idx[i] = XINT (XVECTOR (elt_prefix)->contents[i]);
 	  complete_char
-	    = (CHARSET_VALID_P (idx[0])
-	       && ((CHARSET_DIMENSION (idx[0]) == 1 && this_level == 1)
-		   || this_level == 2));
+	    = (CHARSET_VALID_P (indices[0])
+	       && ((CHARSET_DIMENSION (indices[0]) == 1
+		    && char_table_depth == 1)
+		   || char_table_depth == 2));
 
 	  /* Meaningful elements are from 32th to 127th.  */
 	  from = 32;
 	  to = SUB_CHAR_TABLE_ORDINARY_SLOTS;
 	}
-      chartable_kludge = Fmake_vector (make_number (this_level + 1), Qnil);
-      if (this_level != 0)
-	bcopy (XVECTOR (elt_prefix)->contents,
-	       XVECTOR (chartable_kludge)->contents,
-	       this_level * sizeof (Lisp_Object));
     }
   else
     {
-      this_level = 0;
-      from = 0;
       /* This does the right thing for ordinary vectors.  */
-      to = XFASTINT (Flength (vector));
-      /* Now, can this be just `XVECTOR (vector)->size'? -- K.Handa  */
+
+      complete_char = 1;
+      from = 0;
+      to = XVECTOR (vector)->size;
     }
 
   for (i = from; i < to; i++)
@@ -2620,10 +2785,15 @@ describe_vector (vector, elt_prefix, elt_describer,
 
       if (CHAR_TABLE_P (vector))
 	{
+	  if (char_table_depth == 0 && i >= CHAR_TABLE_SINGLE_BYTE_SLOTS)
+	    complete_char = 0;
+
 	  if (i >= CHAR_TABLE_SINGLE_BYTE_SLOTS
 	      && !CHARSET_DEFINED_P (i - 128))
 	    continue;
-	  definition = get_keyelt (XCHAR_TABLE (vector)->contents[i], 0);
+
+	  definition
+	    = get_keyelt (XCHAR_TABLE (vector)->contents[i], 0);
 	}
       else
 	definition = get_keyelt (XVECTOR (vector)->contents[i], 0);
@@ -2640,12 +2810,34 @@ describe_vector (vector, elt_prefix, elt_describer,
 	  if (!NILP (tem)) continue;
 	}
 
+      /* Set CHARACTER to the character this entry describes, if any.
+	 Also update *INDICES.  */
+      if (CHAR_TABLE_P (vector))
+	{
+	  indices[char_table_depth] = i;
+
+	  if (char_table_depth == 0)
+	    {
+	      character = i;
+	      indices[0] = i - 128;
+	    }
+	  else if (complete_char)
+	    {
+	      character
+		= MAKE_NON_ASCII_CHAR (indices[0], indices[1], indices[2]);
+	    }
+	  else
+	    character = 0;
+	}
+      else
+	character = i;
+
       /* If this binding is shadowed by some other map, ignore it.  */
-      if (!NILP (shadow))
+      if (!NILP (shadow) && complete_char)
 	{
 	  Lisp_Object tem;
 	  
-	  XVECTOR (kludge)->contents[0] = make_number (i);
+	  XVECTOR (kludge)->contents[0] = make_number (character);
 	  tem = shadow_lookup (shadow, kludge, Qt);
 
 	  if (!NILP (tem)) continue;
@@ -2653,11 +2845,11 @@ describe_vector (vector, elt_prefix, elt_describer,
 
       /* Ignore this definition if it is shadowed by an earlier
 	 one in the same keymap.  */
-      if (!NILP (entire_map))
+      if (!NILP (entire_map) && complete_char)
 	{
 	  Lisp_Object tem;
 
-	  XVECTOR (kludge)->contents[0] = make_number (i);
+	  XVECTOR (kludge)->contents[0] = make_number (character);
 	  tem = Flookup_key (entire_map, kludge, Qt);
 
 	  if (! EQ (tem, definition))
@@ -2666,23 +2858,39 @@ describe_vector (vector, elt_prefix, elt_describer,
 
       if (first)
 	{
-	  if (this_level == 0)
+	  if (char_table_depth == 0)
 	    insert ("\n", 1);
 	  first = 0;
 	}
 
-      /* If VECTOR is a sub char-table, show the depth by indentation.
-	 THIS_LEVEL can be greater than 0 only for char-table.  */
-      if (this_level > 0)
-	insert ("    ", this_level * 2); /* THIS_LEVEL is 1 or 2.  */
+      /* For a sub char-table, show the depth by indentation.
+	 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table.  */
+      if (char_table_depth > 0)
+	insert ("    ", char_table_depth * 2); /* depth is 1 or 2.  */
 
-      /* Get a Lisp object for the character I.  */
-      XSETFASTINT (dummy, i);
+      /* Output the prefix that applies to every entry in this map.  */
+      if (!NILP (elt_prefix))
+	insert1 (elt_prefix);
 
-      if (this_level == 0 && CHAR_TABLE_P (vector))
+      /* Insert or describe the character this slot is for,
+	 or a description of what it is for.  */
+      if (SUB_CHAR_TABLE_P (vector))
 	{
-	  if (i < CHAR_TABLE_SINGLE_BYTE_SLOTS)
-	    insert1 (Fsingle_key_description (dummy));
+	  if (complete_char)
+	    insert_char (character);
+	  else
+	    {
+	      /* We need an octal representation for this block of
+                 characters.  */
+	      char work[5];
+	      sprintf (work, "\\%03o", i & 255);
+	      insert (work, 4);
+	    }
+	}
+      else if (CHAR_TABLE_P (vector))
+	{
+	  if (complete_char)
+	    insert1 (Fsingle_key_description (make_number (character)));
 	  else
 	    {
 	      /* Print the information for this character set.  */
@@ -2695,32 +2903,9 @@ describe_vector (vector, elt_prefix, elt_describer,
 	      insert (">", 1);
 	    }
 	}
-      else if (this_level > 0 && SUB_CHAR_TABLE_P (vector))
-	{
-	  if (complete_char)
-	    {
-	      /* Combine ELT_PREFIX with I to produce a character code,
-		 then insert that character's description.  */
-	      idx[this_level] = i;
-	      insert_char (MAKE_NON_ASCII_CHAR (idx[0], idx[1], idx[2]));
-	    }
-	  else
-	    {
-	      /* We need an octal representation for this block of
-                 characters.  */
-	      char work[5];
-	      sprintf (work, "\\%03o", i & 255);
-	      insert (work, 4);
-	    }
-	}
       else
 	{
-	  /* Output the prefix that applies to every entry in this map.  */
-	  if (!NILP (elt_prefix))
-	    insert1 (elt_prefix);
-
-	  /* Get the string to describe the character DUMMY, and print it.  */
-	  insert1 (Fsingle_key_description (dummy));
+	  insert1 (Fsingle_key_description (make_number (character)));
 	}
 
       /* If we find a sub char-table within a char-table,
@@ -2729,34 +2914,33 @@ describe_vector (vector, elt_prefix, elt_describer,
       if (multibyte && CHAR_TABLE_P (vector) && SUB_CHAR_TABLE_P (definition))
 	{
 	  insert ("\n", 1);
-	  XVECTOR (chartable_kludge)->contents[this_level] = make_number (i);
-	  describe_vector (definition, chartable_kludge, elt_describer,
-			   partial, shadow, entire_map);
+	  describe_vector (definition, elt_prefix, elt_describer,
+			   partial, shadow, entire_map,
+			   indices, char_table_depth + 1);
 	  continue;
 	}
 
+      starting_i = i;
+
       /* Find all consecutive characters that have the same
          definition.  But, for elements of a top level char table, if
          they are for charsets, we had better describe one by one even
          if they have the same definition.  */
       if (CHAR_TABLE_P (vector))
 	{
-	  if (this_level == 0)
-	    while (i + 1 < CHAR_TABLE_SINGLE_BYTE_SLOTS
-		   && (tem2
-		       = get_keyelt (XCHAR_TABLE (vector)->contents[i + 1], 0),
-		       !NILP (tem2))
-		   && !NILP (Fequal (tem2, definition)))
-	      i++;
-	  else
-	    while (i + 1 < to
-		   && (tem2 = get_keyelt (XCHAR_TABLE (vector)->contents[i + 1], 0),
-		       !NILP (tem2))
-		   && !NILP (Fequal (tem2, definition)))
-	      i++;
+	  int limit = to;
+
+	  if (char_table_depth == 0)
+	    limit = CHAR_TABLE_SINGLE_BYTE_SLOTS;
+
+	  while (i + 1 < limit
+		 && (tem2 = get_keyelt (XCHAR_TABLE (vector)->contents[i + 1], 0),
+		     !NILP (tem2))
+		 && !NILP (Fequal (tem2, definition)))
+	    i++;
 	}
       else
-	while (i + 1 < CHAR_TABLE_SINGLE_BYTE_SLOTS
+	while (i + 1 < to
 	       && (tem2 = get_keyelt (XVECTOR (vector)->contents[i + 1], 0),
 		   !NILP (tem2))
 	       && !NILP (Fequal (tem2, definition)))
@@ -2766,35 +2950,36 @@ describe_vector (vector, elt_prefix, elt_describer,
       /* If we have a range of more than one character,
 	 print where the range reaches to.  */
 
-      if (i != XINT (dummy))
+      if (i != starting_i)
 	{
 	  insert (" .. ", 4);
+
+	  if (!NILP (elt_prefix))
+	    insert1 (elt_prefix);
+
 	  if (CHAR_TABLE_P (vector))
 	    {
-	      if (complete_char)
+	      if (char_table_depth == 0)
 		{
-		  idx[this_level] = i;
-		  insert_char (MAKE_NON_ASCII_CHAR (idx[0], idx[1], idx[2]));
+		  insert1 (Fsingle_key_description (make_number (i)));
 		}
-	      else if (this_level > 0)
+	      else if (complete_char)
 		{
-		  char work[5];
-		  sprintf (work, "\\%03o", i & 255);
-		  insert (work, 4);
+		  indices[char_table_depth] = i;
+		  character
+		    = MAKE_NON_ASCII_CHAR (indices[0], indices[1], indices[2]);
+		  insert_char (character);
 		}
 	      else
 		{
-		  XSETFASTINT (dummy, i);
-		  insert1 (Fsingle_key_description (dummy));
+		  char work[5];
+		  sprintf (work, "\\%03o", i & 255);
+		  insert (work, 4);
 		}
 	    }
 	  else
 	    {
-	      if (!NILP (elt_prefix) && !CHAR_TABLE_P (vector))
-		insert1 (elt_prefix);
-
-	      XSETFASTINT (dummy, i);
-	      insert1 (Fsingle_key_description (dummy));
+	      insert1 (Fsingle_key_description (make_number (i)));
 	    }
 	}
 
@@ -2807,7 +2992,7 @@ describe_vector (vector, elt_prefix, elt_describer,
   /* For (sub) char-table, print `defalt' slot at last.  */
   if (CHAR_TABLE_P (vector) && !NILP (XCHAR_TABLE (vector)->defalt))
     {
-      insert ("    ", this_level * 2);
+      insert ("    ", char_table_depth * 2);
       insert_string ("<<default>>");
       (*elt_describer) (XCHAR_TABLE (vector)->defalt);
     }
@@ -2858,12 +3043,15 @@ syms_of_keymap ()
   Qkeymap = intern ("keymap");
   staticpro (&Qkeymap);
 
-/* Initialize the keymaps standardly used.
-   Each one is the value of a Lisp variable, and is also
-   pointed to by a C variable */
+  /* Now we are ready to set up this property, so we can
+     create char tables.  */
+  Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));
+
+  /* Initialize the keymaps standardly used.
+     Each one is the value of a Lisp variable, and is also
+     pointed to by a C variable */
 
-  global_map = Fcons (Qkeymap,
-		      Fcons (Fmake_vector (make_number (0400), Qnil), Qnil));
+  global_map = Fmake_keymap (Qnil);
   Fset (intern ("global-map"), global_map);
 
   current_global_map = global_map;