Merge from trunk; up to 2014-02-23T23:41:17Z!lekktu@gmail.com.

1 files changed, 63 insertions, 46 deletions

diff --git a/src/keymap.c b/src/keymap.c
index 922c1703edf..c1416f8a780 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,5 @@
 /* Manipulation of keymaps
-   Copyright (C) 1985-1988, 1993-1995, 1998-2013 Free Software
+   Copyright (C) 1985-1988, 1993-1995, 1998-2014 Free Software
    Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -56,28 +56,28 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keymap.h"
 #include "window.h"
 
-/* Actually allocate storage for these variables */
+/* Actually allocate storage for these variables.  */
 
-Lisp_Object current_global_map; /* Current global keymap */
+Lisp_Object current_global_map; /* Current global keymap.  */
 
-Lisp_Object global_map;         /* default global key bindings */
+Lisp_Object global_map;         /* Default global key bindings.  */
 
 Lisp_Object meta_map;           /* The keymap used for globally bound
-                                   ESC-prefixed default commands */
+                                   ESC-prefixed default commands.  */
 
 Lisp_Object control_x_map;      /* The keymap used for globally bound
-                                   C-x-prefixed default commands */
+                                   C-x-prefixed default commands.  */
 
                                 /* The keymap used by the minibuf for local
                                    bindings when spaces are allowed in the
-                                   minibuf */
+                                   minibuf.  */
 
                                 /* The keymap used by the minibuf for local
                                    bindings when spaces are not encouraged
-                                   in the minibuf */
+                                   in the minibuf.  */
 
-/* keymap used for minibuffers when doing completion */
-/* keymap used for minibuffers when doing completion and require a match */
+/* Keymap used for minibuffers when doing completion.  */
+/* Keymap used for minibuffers when doing completion and require a match.  */
 static Lisp_Object Qkeymapp, Qnon_ascii;
 Lisp_Object Qkeymap, Qmenu_item, Qremap;
 static Lisp_Object QCadvertised_binding;
@@ -106,6 +106,12 @@ static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
                              Lisp_Object, Lisp_Object, bool, bool);
 static void silly_event_symbol_error (Lisp_Object);
 static Lisp_Object get_keyelt (Lisp_Object, bool);
+
+static void
+CHECK_VECTOR_OR_CHAR_TABLE (Lisp_Object x)
+{
+  CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x);
+}
 
 /* Keymap object support - constructors and predicates.                 */
 
@@ -123,7 +129,7 @@ in case you use it as a menu with `x-popup-menu'.  */)
 {
   Lisp_Object tail;
   if (!NILP (string))
-    tail = Fcons (string, Qnil);
+    tail = list1 (string);
   else
     tail = Qnil;
   return Fcons (Qkeymap,
@@ -145,9 +151,9 @@ in case you use it as a menu with `x-popup-menu'.  */)
     {
       if (!NILP (Vpurify_flag))
         string = Fpurecopy (string);
-      return Fcons (Qkeymap, Fcons (string, Qnil));
+      return list2 (Qkeymap, string);
     }
-  return Fcons (Qkeymap, Qnil);
+  return list1 (Qkeymap);
 }
 
 /* This function is used for installing the standard key bindings
@@ -528,12 +534,12 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
               retval = val;
             else if (CONSP (retval_tail))
               {
-                XSETCDR (retval_tail, Fcons (val, Qnil));
+                XSETCDR (retval_tail, list1 (val));
                 retval_tail = XCDR (retval_tail);
               }
             else
               {
-                retval_tail = Fcons (val, Qnil);
+                retval_tail = list1 (val);
                 retval = Fcons (Qkeymap, Fcons (retval, retval_tail));
               }
           }
@@ -565,7 +571,8 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
 {
   if (!NILP (val))
     {
-      map_keymap_function_t fun = XSAVE_POINTER (args, 0);
+      map_keymap_function_t fun
+        = (map_keymap_function_t) XSAVE_FUNCPOINTER (args, 0);
       /* If the key is a range, make a copy since map_char_table modifies
          it in place.  */
       if (CONSP (key))
@@ -610,7 +617,8 @@ map_keymap_internal (Lisp_Object map,
         }
       else if (CHAR_TABLE_P (binding))
         map_char_table (map_keymap_char_table_item, Qnil, binding,
-                        make_save_value ("ppo", fun, data, args));
+                        make_save_funcptr_ptr_obj ((voidfuncptr) fun, data,
+                                                   args));
     }
   UNGCPRO;
   return tail;
@@ -1037,9 +1045,9 @@ However, a key definition which is a symbol whose definition is a keymap
 is not copied.  */)
   (Lisp_Object keymap)
 {
-  register Lisp_Object copy, tail;
+  Lisp_Object copy, tail;
   keymap = get_keymap (keymap, 1, 0);
-  copy = tail = Fcons (Qkeymap, Qnil);
+  copy = tail = list1 (Qkeymap);
   keymap = XCDR (keymap);               /* Skip the `keymap' symbol.  */
 
   while (CONSP (keymap) && !EQ (XCAR (keymap), Qkeymap))
@@ -1065,7 +1073,7 @@ is not copied.  */)
           else
             elt = Fcons (XCAR (elt), copy_keymap_item (XCDR (elt)));
         }
-      XSETCDR (tail, Fcons (elt, Qnil));
+      XSETCDR (tail, list1 (elt));
       tail = XCDR (tail);
       keymap = XCDR (keymap);
     }
@@ -1333,8 +1341,7 @@ append_key (Lisp_Object key_sequence, Lisp_Object key)
   Lisp_Object args[2];
 
   args[0] = key_sequence;
-
-  args[1] = Fcons (key, Qnil);
+  args[1] = list1 (key);
   return Fvconcat (2, args);
 }
 
@@ -1541,7 +1548,7 @@ like in the respective argument of `key-binding'.  */)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
 
-  Lisp_Object keymaps = Fcons (current_global_map, Qnil);
+  Lisp_Object keymaps = list1 (current_global_map);
 
   /* If a mouse click position is given, our variables are based on
      the buffer clicked on, not the current buffer.  So we may have to
@@ -1554,8 +1561,8 @@ like in the respective argument of `key-binding'.  */)
       window = POSN_WINDOW (position);
 
       if (WINDOWP (window)
-          && BUFFERP (XWINDOW (window)->buffer)
-          && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+          && BUFFERP (XWINDOW (window)->contents)
+          && XBUFFER (XWINDOW (window)->contents) != current_buffer)
         {
           /* Arrange to go back to the original buffer once we're done
              processing the key sequence.  We don't use
@@ -1565,21 +1572,18 @@ like in the respective argument of `key-binding'.  */)
              things the same.
           */
           record_unwind_current_buffer ();
-          set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+          set_buffer_internal (XBUFFER (XWINDOW (window)->contents));
         }
     }
 
-  if (!NILP (olp))
-    {
-      if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
-        keymaps = Fcons (KVAR (current_kboard, Voverriding_terminal_local_map),
-                         keymaps);
+  if (!NILP (olp)
       /* The doc said that overriding-terminal-local-map should
          override overriding-local-map.  The code used them both,
          but it seems clearer to use just one.  rms, jan 2005.  */
-      else if (!NILP (Voverriding_local_map))
-        keymaps = Fcons (Voverriding_local_map, keymaps);
-    }
+      && NILP (KVAR (current_kboard, Voverriding_terminal_local_map))
+      && !NILP (Voverriding_local_map))
+    keymaps = Fcons (Voverriding_local_map, keymaps);
+
   if (NILP (XCDR (keymaps)))
     {
       Lisp_Object *maps;
@@ -1590,6 +1594,7 @@ like in the respective argument of `key-binding'.  */)
       Lisp_Object local_map = get_local_map (pt, current_buffer, Qlocal_map);
       /* This returns nil unless there is a `keymap' property.  */
       Lisp_Object keymap = get_local_map (pt, current_buffer, Qkeymap);
+      Lisp_Object otlp = KVAR (current_kboard, Voverriding_terminal_local_map);
 
       if (CONSP (position))
         {
@@ -1654,6 +1659,9 @@ like in the respective argument of `key-binding'.  */)
 
       if (!NILP (keymap))
         keymaps = Fcons (keymap, keymaps);
+
+      if (!NILP (olp) && !NILP (otlp))
+        keymaps = Fcons (otlp, keymaps);
     }
 
   unbind_to (count, Qnil);
@@ -1800,7 +1808,7 @@ bindings; see the description of `lookup-key' for more details about this.  */)
         if (KEYMAPP (binding))
           maps[j++] = Fcons (modes[i], binding);
         else if (j == 0)
-          RETURN_UNGCPRO (Fcons (Fcons (modes[i], binding), Qnil));
+          RETURN_UNGCPRO (list1 (Fcons (modes[i], binding)));
       }
 
   UNGCPRO;
@@ -1942,7 +1950,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
   else
     {
       tem = append_key (thisseq, key);
-      nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
+      nconc2 (tail, list1 (Fcons (tem, cmd)));
     }
 }
 
@@ -1996,13 +2004,13 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
                 }
               prefix = copy;
             }
-          maps = Fcons (Fcons (prefix, tem), Qnil);
+          maps = list1 (Fcons (prefix, tem));
         }
       else
         return Qnil;
     }
   else
-    maps = Fcons (Fcons (zero_vector, get_keymap (keymap, 1, 0)), Qnil);
+    maps = list1 (Fcons (zero_vector, get_keymap (keymap, 1, 0)));
 
   /* For each map in the list maps,
      look at any other maps it points to,
@@ -2310,7 +2318,6 @@ around function keys and event symbols.  */)
     return Fcopy_sequence (key);
   else
     error ("KEY must be an integer, cons, symbol, or string");
-  return Qnil;
 }
 
 static char *
@@ -2611,7 +2618,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
   if (CONSP (keymap) && KEYMAPP (XCAR (keymap)))
     keymaps = keymap;
   else if (!NILP (keymap))
-    keymaps = Fcons (keymap, Fcons (current_global_map, Qnil));
+    keymaps = list2 (keymap, current_global_map);
   else
     keymaps = Fcurrent_active_maps (Qnil, Qnil);
 
@@ -2850,7 +2857,7 @@ You type        Translation\n\
 
             insert ("\n", 1);
 
-            /* Insert calls signal_after_change which may GC. */
+            /* Insert calls signal_after_change which may GC.  */
             translate = SDATA (KVAR (current_kboard, Vkeyboard_translate_table));
           }
 
@@ -2866,6 +2873,14 @@ You type        Translation\n\
   start1 = Qnil;
   if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
     start1 = KVAR (current_kboard, Voverriding_terminal_local_map);
+
+  if (!NILP (start1))
+    {
+      describe_map_tree (start1, 1, shadow, prefix,
+                         "\f\nOverriding Bindings", nomenu, 0, 0, 0);
+      shadow = Fcons (start1, shadow);
+      start1 = Qnil;
+    }
   else if (!NILP (Voverriding_local_map))
     start1 = Voverriding_local_map;
 
@@ -3234,8 +3249,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     length_needed++;
 
-  vect = ((struct describe_map_elt *)
-          alloca (sizeof (struct describe_map_elt) * length_needed));
+  vect = alloca (length_needed * sizeof *vect);
 
   for (tail = map; CONSP (tail); tail = XCDR (tail))
     {
@@ -3369,9 +3383,12 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
 
       if (vect[i].shadowed)
         {
-          SET_PT (PT - 1);
+          ptrdiff_t pt = max (PT - 1, BEG);
+
+          SET_PT (pt);
           insert_string ("\n  (that binding is currently shadowed by another mode)");
-          SET_PT (PT + 1);
+          pt = min (PT + 1, Z);
+          SET_PT (pt);
         }
     }
 
@@ -3736,7 +3753,7 @@ it is provided for major modes to bind locally.  */);
   Vminor_mode_overriding_map_alist = Qnil;
 
   DEFVAR_LISP ("emulation-mode-map-alists", Vemulation_mode_map_alists,
-               doc: /* List of keymap alists to use for emulations modes.
+               doc: /* List of keymap alists to use for emulation modes.
 It is intended for modes or packages using multiple minor-mode keymaps.
 Each element is a keymap alist just like `minor-mode-map-alist', or a
 symbol with a variable binding which is a keymap alist, and it is used