(keymap_parent): New fun, extracted from Fkeymap_parent.

(Fkeymap_parent, keymap_memberp, fix_submap_inheritance): Use it.
(Fset_keymap_parent): Gcpro a bit more.
(access_keymap): Gcpro around meta_map call and around the main loop.
(get_keyelt): Gcpro when following indirect references.
(copy_keymap_item): New fun, extracted from Fcopy_keymap.
(copy_keymap_1, Fcopy_keymap): Use it.  Don't copy the parent map.
(Fdefine_key, Flookup_key): Gcpro before calling get_keymap.
Remove useless ad-hoc remap code.

1 files changed, 153 insertions, 170 deletions

diff --git a/src/keymap.c b/src/keymap.c
index a119a2fa49d..e68210cf81b 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -273,11 +273,11 @@ get_keymap (object, error, autoload)
 	      if (autoload)
 		{
 		  struct gcpro gcpro1, gcpro2;
-		  
+
 		  GCPRO2 (tem, object);
 		  do_autoload (tem, object);
 		  UNGCPRO;
-		  
+
 		  goto autoload_retry;
 		}
 	      else
@@ -292,17 +292,17 @@ get_keymap (object, error, autoload)
   return Qnil;
 }
 
-/* Return the parent map of the keymap MAP, or nil if it has none.
-   We assume that MAP is a valid keymap.  */
+/* Return the parent map of KEYMAP, or nil if it has none.
+   We assume that KEYMAP is a valid keymap.  */
 
-DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
-       doc: /* Return the parent keymap of KEYMAP.  */)
-     (keymap)
+Lisp_Object
+keymap_parent (keymap, autoload)
      Lisp_Object keymap;
+     int autoload;
 {
   Lisp_Object list;
 
-  keymap = get_keymap (keymap, 1, 1);
+  keymap = get_keymap (keymap, 1, autoload);
 
   /* Skip past the initial element `keymap'.  */
   list = XCDR (keymap);
@@ -313,9 +313,16 @@ DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
 	return list;
     }
 
-  return get_keymap (list, 0, 1);
+  return get_keymap (list, 0, autoload);
 }
 
+DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
+       doc: /* Return the parent keymap of KEYMAP.  */)
+     (keymap)
+     Lisp_Object keymap;
+{
+  return keymap_parent (keymap, 1);
+}
 
 /* Check whether MAP is one of MAPS parents.  */
 int
@@ -324,7 +331,7 @@ keymap_memberp (map, maps)
 {
   if (NILP (map)) return 0;
   while (KEYMAPP (maps) && !EQ (map, maps))
-    maps = Fkeymap_parent (maps);
+    maps = keymap_parent (maps, 0);
   return (EQ (map, maps));
 }
 
@@ -337,7 +344,7 @@ PARENT should be nil or another keymap.  */)
      Lisp_Object keymap, parent;
 {
   Lisp_Object list, prev;
-  struct gcpro gcpro1;
+  struct gcpro gcpro1, gcpro2;
   int i;
 
   /* Force a keymap flush for the next call to where-is.
@@ -349,9 +356,9 @@ PARENT should be nil or another keymap.  */)
      This is a very minor correctness (rather than safety) issue.  */
   where_is_cache_keymaps = Qt;
 
+  GCPRO2 (keymap, parent);
   keymap = get_keymap (keymap, 1, 1);
-  GCPRO1 (keymap);
-  
+
   if (!NILP (parent))
     {
       parent = get_keymap (parent, 1, 1);
@@ -432,7 +439,7 @@ fix_submap_inheritance (map, event, submap)
   if (!CONSP (submap))
     return;
 
-  map_parent = Fkeymap_parent (map);
+  map_parent = keymap_parent (map, 0);
   if (!NILP (map_parent))
     parent_entry =
       get_keymap (access_keymap (map_parent, event, 0, 0, 0), 0, 0);
@@ -452,7 +459,7 @@ fix_submap_inheritance (map, event, submap)
 	{
 	  Lisp_Object tem;
 
-	  tem = Fkeymap_parent (submap_parent);
+	  tem = keymap_parent (submap_parent, 0);
 
 	  if (KEYMAPP (tem))
 	    {
@@ -512,10 +519,13 @@ access_keymap (map, idx, t_ok, noinherit, autoload)
     {
       /* See if there is a meta-map.  If there's none, there is
          no binding for IDX, unless a default binding exists in MAP.  */
-      Lisp_Object meta_map =
-	get_keymap (access_keymap (map, meta_prefix_char,
-				   t_ok, noinherit, autoload),
-		    0, autoload);
+      struct gcpro gcpro1;
+      Lisp_Object meta_map;
+      GCPRO1 (map);
+      meta_map = get_keymap (access_keymap (map, meta_prefix_char,
+					    t_ok, noinherit, autoload),
+			     0, autoload);
+      UNGCPRO;
       if (CONSP (meta_map))
 	{
 	  map = meta_map;
@@ -529,15 +539,15 @@ access_keymap (map, idx, t_ok, noinherit, autoload)
 	return Qnil;
     }
 
+  /* t_binding is where we put a default binding that applies,
+     to use in case we do not find a binding specifically
+     for this key sequence.  */
   {
     Lisp_Object tail;
+    Lisp_Object t_binding = Qnil;
+    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
-    /* t_binding is where we put a default binding that applies,
-       to use in case we do not find a binding specifically
-       for this key sequence.  */
-
-    Lisp_Object t_binding;
-    t_binding = Qnil;
+    GCPRO4 (map, tail, idx, t_binding);
 
     /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
        If it is 1, only generic-char bindings are accepted.
@@ -557,7 +567,7 @@ access_keymap (map, idx, t_ok, noinherit, autoload)
 	    /* If NOINHERIT, stop finding prefix definitions
 	       after we pass a second occurrence of the `keymap' symbol.  */
 	    if (noinherit && EQ (binding, Qkeymap))
-	      return Qnil;
+	      RETURN_UNGCPRO (Qnil);
 	  }
 	else if (CONSP (binding))
 	  {
@@ -621,11 +631,11 @@ access_keymap (map, idx, t_ok, noinherit, autoload)
 	    val = get_keyelt (val, autoload);
 	    if (KEYMAPP (val))
 	      fix_submap_inheritance (map, idx, val);
-	    return val;
+	    RETURN_UNGCPRO (val);
 	  }
 	QUIT;
       }
-
+    UNGCPRO;
     return get_keyelt (t_binding, autoload);
   }
 }
@@ -644,7 +654,7 @@ access_keymap (map, idx, t_ok, noinherit, autoload)
 
 Lisp_Object
 get_keyelt (object, autoload)
-     register Lisp_Object object;
+     Lisp_Object object;
      int autoload;
 {
   while (1)
@@ -686,7 +696,7 @@ get_keyelt (object, autoload)
 		  }
 	    }
 	  else
-	    /* Invalid keymap */
+	    /* Invalid keymap.  */
 	    return object;
 	}
 
@@ -713,8 +723,11 @@ get_keyelt (object, autoload)
       /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
       else
 	{
+	  struct gcpro gcpro1;
 	  Lisp_Object map;
+	  GCPRO1 (object);
 	  map = get_keymap (Fcar_safe (object), 0, autoload);
+	  UNGCPRO;
 	  return (!CONSP (map) ? object /* Invalid keymap */
 		  : access_keymap (map, Fcdr (object), 0, 0, autoload));
 	}
@@ -821,18 +834,91 @@ store_in_keymap (keymap, idx, def)
     XSETCDR (insertion_point,
 	     Fcons (Fcons (idx, def), XCDR (insertion_point)));
   }
-  
+
   return def;
 }
 
 EXFUN (Fcopy_keymap, 1);
 
+Lisp_Object
+copy_keymap_item (elt)
+     Lisp_Object elt;
+{
+  Lisp_Object res, tem;
+
+  if (!CONSP (elt))
+    return elt;
+
+  res = tem = elt;
+
+  /* Is this a new format menu item.  */
+  if (EQ (XCAR (tem), Qmenu_item))
+    {
+      /* Copy cell with menu-item marker.  */
+      res = elt = Fcons (XCAR (tem), XCDR (tem));
+      tem = XCDR (elt);
+      if (CONSP (tem))
+	{
+	  /* Copy cell with menu-item name.  */
+	  XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
+	  elt = XCDR (elt);
+	  tem = XCDR (elt);
+	}
+      if (CONSP (tem))
+	{
+	  /* Copy cell with binding and if the binding is a keymap,
+	     copy that.  */
+	  XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
+	  elt = XCDR (elt);
+	  tem = XCAR (elt);
+	  if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
+	    XSETCAR (elt, Fcopy_keymap (tem));
+	  tem = XCDR (elt);
+	  if (CONSP (tem) && CONSP (XCAR (tem)))
+	    /* Delete cache for key equivalences.  */
+	    XSETCDR (elt, XCDR (tem));
+	}
+    }
+  else
+    {
+      /* It may be an old fomat menu item.
+	 Skip the optional menu string.  */
+      if (STRINGP (XCAR (tem)))
+	{
+	  /* Copy the cell, since copy-alist didn't go this deep.  */
+	  res = elt = Fcons (XCAR (tem), XCDR (tem));
+	  tem = XCDR (elt);
+	  /* Also skip the optional menu help string.  */
+	  if (CONSP (tem) && STRINGP (XCAR (tem)))
+	    {
+	      XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
+	      elt = XCDR (elt);
+	      tem = XCDR (elt);
+	    }
+	  /* There may also be a list that caches key equivalences.
+	     Just delete it for the new keymap.  */
+	  if (CONSP (tem)
+	      && CONSP (XCAR (tem))
+	      && (NILP (XCAR (XCAR (tem)))
+		  || VECTORP (XCAR (XCAR (tem)))))
+	    {
+	      XSETCDR (elt, XCDR (tem));
+	      tem = XCDR (tem);
+	    }
+	  if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
+	    XSETCDR (elt, Fcopy_keymap (tem));
+	}
+      else if (EQ (XCAR (tem), Qkeymap))
+	res = Fcopy_keymap (elt);
+    }
+  return res;
+}
+
 void
 copy_keymap_1 (chartable, idx, elt)
      Lisp_Object chartable, idx, elt;
 {
-  if (CONSP (elt) && EQ (XCAR (elt), Qkeymap))
-    Faset (chartable, idx, Fcopy_keymap (elt));
+  Faset (chartable, idx, copy_keymap_item (elt));
 }
 
 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
@@ -845,112 +931,34 @@ is not copied.  */)
      (keymap)
      Lisp_Object keymap;
 {
-  /* FIXME: This doesn't properly copy menu-items in vectors.  */
-  /* FIXME: This also copies the parent keymap.  */
-
   register Lisp_Object copy, tail;
+  keymap = get_keymap (keymap, 1, 0);
+  copy = tail = Fcons (Qkeymap, Qnil);
+  keymap = XCDR (keymap);		/* Skip the `keymap' symbol.  */
 
-  copy = Fcopy_alist (get_keymap (keymap, 1, 0));
-
-  for (tail = copy; CONSP (tail); tail = XCDR (tail))
+  while (CONSP (keymap) && !EQ (XCAR (keymap), Qkeymap))
     {
-      Lisp_Object elt;
-
-      elt = XCAR (tail);
+      Lisp_Object elt = XCAR (keymap);
       if (CHAR_TABLE_P (elt))
 	{
 	  Lisp_Object indices[3];
-
 	  elt = Fcopy_sequence (elt);
-	  XSETCAR (tail, elt);
-
 	  map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
 	}
       else if (VECTORP (elt))
 	{
 	  int i;
-
 	  elt = Fcopy_sequence (elt);
-	  XSETCAR (tail, elt);
-
 	  for (i = 0; i < ASIZE (elt); i++)
-	    if (CONSP (AREF (elt, i)) && EQ (XCAR (AREF (elt, i)), Qkeymap))
-	      ASET (elt, i, Fcopy_keymap (AREF (elt, i)));
-	}
-      else if (CONSP (elt) && CONSP (XCDR (elt)))
-	{
-	  Lisp_Object tem;
-	  tem = XCDR (elt);
-
-	  /* Is this a new format menu item.  */
-	  if (EQ (XCAR (tem),Qmenu_item))
-	    {
-	      /* Copy cell with menu-item marker.  */
-	      XSETCDR (elt,
-		       Fcons (XCAR (tem), XCDR (tem)));
-	      elt = XCDR (elt);
-	      tem = XCDR (elt);
-	      if (CONSP (tem))
-		{
-		  /* Copy cell with menu-item name.  */
-		  XSETCDR (elt,
-			   Fcons (XCAR (tem), XCDR (tem)));
-		  elt = XCDR (elt);
-		  tem = XCDR (elt);
-		};
-	      if (CONSP (tem))
-		{
-		  /* Copy cell with binding and if the binding is a keymap,
-		     copy that.  */
-		  XSETCDR (elt,
-			   Fcons (XCAR (tem), XCDR (tem)));
-		  elt = XCDR (elt);
-		  tem = XCAR (elt);
-		  if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
-		    XSETCAR (elt, Fcopy_keymap (tem));
-		  tem = XCDR (elt);
-		  if (CONSP (tem) && CONSP (XCAR (tem)))
-		    /* Delete cache for key equivalences.  */
-		    XSETCDR (elt, XCDR (tem));
-		}
-	    }
-	  else
-	    {
-	      /* It may be an old fomat menu item.
-		 Skip the optional menu string.
-	      */
-	      if (STRINGP (XCAR (tem)))
-		{
-		  /* Copy the cell, since copy-alist didn't go this deep.  */
-		  XSETCDR (elt,
-			   Fcons (XCAR (tem), XCDR (tem)));
-		  elt = XCDR (elt);
-		  tem = XCDR (elt);
-		  /* Also skip the optional menu help string.  */
-		  if (CONSP (tem) && STRINGP (XCAR (tem)))
-		    {
-		      XSETCDR (elt,
-			       Fcons (XCAR (tem), XCDR (tem)));
-		      elt = XCDR (elt);
-		      tem = XCDR (elt);
-		    }
-		  /* There may also be a list that caches key equivalences.
-		     Just delete it for the new keymap.  */
-		  if (CONSP (tem)
-		      && CONSP (XCAR (tem))
-		      && (NILP (XCAR (XCAR (tem)))
-			  || VECTORP (XCAR (XCAR (tem)))))
-		    XSETCDR (elt, XCDR (tem));
-		}
-	      if (CONSP (elt)
-		  && CONSP (XCDR (elt))
-		  && EQ (XCAR (XCDR (elt)), Qkeymap))
-		XSETCDR (elt, Fcopy_keymap (XCDR (elt)));
-	    }
-
+	    ASET (elt, i, copy_keymap_item (AREF (elt, i)));
 	}
+      else if (CONSP (elt))
+	elt = Fcons (XCAR (elt), copy_keymap_item (XCDR (elt)));
+      XSETCDR (tail, Fcons (elt, Qnil));
+      tail = XCDR (tail);
+      keymap = XCDR (keymap);
     }
-  
+  XSETCDR (tail, keymap);
   return copy;
 }
 
@@ -993,29 +1001,20 @@ the front of KEYMAP.  */)
   int length;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
+  GCPRO3 (keymap, key, def);
   keymap = get_keymap (keymap, 1, 1);
 
   if (!VECTORP (key) && !STRINGP (key))
-      key = wrong_type_argument (Qarrayp, key);
+    key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));
   if (length == 0)
-    return Qnil;
-
-  /* Check for valid [remap COMMAND] bindings.  */
-  if (VECTORP (key) && EQ (AREF (key, 0), Qremap)
-      && (length != 2 || !SYMBOLP (AREF (key, 1))))
-    wrong_type_argument (Qvectorp, key);
+    RETURN_UNGCPRO (Qnil);
 
   if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
     Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);
 
-  GCPRO3 (keymap, key, def);
-
-  if (VECTORP (key))
-    meta_bit = meta_modifier;
-  else
-    meta_bit = 0x80;
+  meta_bit = VECTORP (key) ? meta_modifier : 0x80;
 
   idx = 0;
   while (1)
@@ -1073,7 +1072,6 @@ Returns nil if COMMAND is not remapped.  */)
      (command)
      Lisp_Object command;
 {
-  /* This will GCPRO the command argument.  */
   ASET (remap_command_vector, 1, command);
   return Fkey_binding (remap_command_vector, Qnil, Qt);
 }
@@ -1097,7 +1095,7 @@ usable as a general function for probing keymaps.  However, if the
 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
 recognize the default bindings, just as `read-key-sequence' does.  */)
      (keymap, key, accept_default)
-     register Lisp_Object keymap;
+     Lisp_Object keymap;
      Lisp_Object key;
      Lisp_Object accept_default;
 {
@@ -1106,32 +1104,17 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
   register Lisp_Object c;
   int length;
   int t_ok = !NILP (accept_default);
-  struct gcpro gcpro1;
+  struct gcpro gcpro1, gcpro2;
 
+  GCPRO2 (keymap, key);
   keymap = get_keymap (keymap, 1, 1);
 
-  /* Perform command remapping initiated by Fremap_command directly.
-     This is strictly not necessary, but it is faster and it returns
-     nil instead of 1 if KEYMAP doesn't contain command remappings.  */
-  if (EQ (key, remap_command_vector))
-    {
-      /* KEY has format [remap COMMAND]. 
-	 Lookup `remap' in KEYMAP; result is nil or a keymap containing
-	 command remappings.  Then lookup COMMAND in that keymap.  */
-      if ((keymap = access_keymap (keymap, Qremap, t_ok, 0, 1), !NILP (keymap))
-	  && (keymap = get_keymap (keymap, 0, 1), CONSP (keymap)))
-	return access_keymap (keymap, AREF (key, 1), t_ok, 0, 1);
-      return Qnil;
-    }
-
   if (!VECTORP (key) && !STRINGP (key))
     key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));
   if (length == 0)
-    return keymap;
-
-  GCPRO1 (key);
+    RETURN_UNGCPRO (keymap);
 
   idx = 0;
   while (1)
@@ -1413,7 +1396,7 @@ OLP if non-nil indicates that we should obey `overriding-local-map' and
       if (!NILP (local))
 	keymaps = Fcons (local, keymaps);
     }
-  
+
   return keymaps;
 }
 
@@ -1692,9 +1675,9 @@ accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized)
 	      int meta_bit = meta_modifier;
 	      Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1);
 	      tem = Fcopy_sequence (thisseq);
-	      
+
 	      Faset (tem, last, make_number (XINT (key) | meta_bit));
-	      
+
 	      /* This new sequence is the same length as
 		 thisseq, so stick it in the list right
 		 after this one.  */
@@ -1830,13 +1813,13 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
 	      for (i = 0; i < ASIZE (elt); i++)
 		accessible_keymaps_1 (make_number (i), AREF (elt, i),
 				      maps, tail, thisseq, is_metized);
-					
+
 	    }
 	  else if (CONSP (elt))
 	    accessible_keymaps_1 (XCAR (elt), XCDR (elt),
 				  maps, tail, thisseq,
 				  is_metized && INTEGERP (XCAR (elt)));
-				    
+
 	}
     }
 
@@ -1954,7 +1937,7 @@ push_key_description (c, p, force_multibyte)
      int force_multibyte;
 {
   unsigned c2;
-  
+
   /* Clear all the meaningless bits above the meta bit.  */
   c &= meta_modifier | ~ - meta_modifier;
   c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
@@ -2048,7 +2031,7 @@ push_key_description (c, p, force_multibyte)
   else
     {
       int valid_p = SINGLE_BYTE_CHAR_P (c) || char_valid_p (c, 0);
-      
+
       if (force_multibyte && valid_p)
 	{
 	  if (SINGLE_BYTE_CHAR_P (c))
@@ -2281,7 +2264,7 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap)
 		Faccessible_keymaps (get_keymap (XCAR (found), 1, 0), Qnil));
       found = XCDR (found);
     }
- 
+
   GCPRO5 (definition, keymaps, maps, found, sequences);
   found = Qnil;
   sequences = Qnil;
@@ -2310,7 +2293,7 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap)
 	   keymaps bound to `menu-bar' and `tool-bar' and other
 	   non-ascii prefixes like `C-down-mouse-2'.  */
 	continue;
-      
+
       QUIT;
 
       while (CONSP (map))
@@ -2455,7 +2438,7 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap)
      return the best we could find.  */
   if (!NILP (firstonly))
     return Fcar (found);
-    
+
   return found;
 }
 
@@ -2514,7 +2497,7 @@ remapped command in the returned list.  */)
 	  Lisp_Object args[2];
 	  where_is_cache = Fmake_hash_table (0, args);
 	  where_is_cache_keymaps = Qt;
-	  
+
 	  /* Fill in the cache.  */
 	  GCPRO5 (definition, keymaps, firstonly, noindirect, no_remap);
 	  where_is_internal (definition, keymaps, firstonly, noindirect, no_remap);
@@ -2531,7 +2514,7 @@ remapped command in the returned list.  */)
       defns = (Lisp_Object *) alloca (n * sizeof *defns);
       for (i = 0; CONSP (sequences); sequences = XCDR (sequences))
 	defns[i++] = XCAR (sequences);
-      
+
       /* Verify that the key bindings are not shadowed.  Note that
 	 the following can GC.  */
       GCPRO2 (definition, keymaps);
@@ -3315,7 +3298,7 @@ describe_vector (vector, elt_prefix, args, elt_describer,
       if (!NILP (shadow) && complete_char)
 	{
 	  Lisp_Object tem;
-	  
+
 	  ASET (kludge, 0, make_number (character));
 	  tem = shadow_lookup (shadow, kludge, Qt);
 
@@ -3425,7 +3408,7 @@ describe_vector (vector, elt_prefix, args, elt_describer,
 		   !NILP (tem2))
 	       && !NILP (Fequal (tem2, definition)))
 	  i++;
-      
+
 
       /* If we have a range of more than one character,
 	 print where the range reaches to.  */