Separate read and write access to Lisp_Object slots of Lisp_Process.

[gnu-emacs] / src / keymap.c

diff --git a/src/keymap.c b/src/keymap.c
index 54134c6704387b737f44d0bf0669595418056039..a0a3528513158e6271fb38e1fb8115c35513d4b3 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,5 @@
 /* Manipulation of keymaps
 /* Manipulation of keymaps

-   Copyright (C) 1985-1988, 1993-1995, 1998-2011 Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993-1995, 1998-2012 Free Software Foundation, Inc.

 
 This file is part of GNU Emacs.
 
 
 This file is part of GNU Emacs.
 


@@ -43,8 +43,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <setjmp.h>
 #include "lisp.h"
 #include "commands.h"
 #include <setjmp.h>
 #include "lisp.h"
 #include "commands.h"

-#include "buffer.h"

 #include "character.h"
 #include "character.h"

+#include "buffer.h"

 #include "charset.h"
 #include "keyboard.h"
 #include "frame.h"
 #include "charset.h"
 #include "keyboard.h"
 #include "frame.h"


@@ -92,7 +92,6 @@ static Lisp_Object where_is_cache;
 /* Which keymaps are reverse-stored in the cache.  */
 static Lisp_Object where_is_cache_keymaps;
 
 /* Which keymaps are reverse-stored in the cache.  */
 static Lisp_Object where_is_cache_keymaps;
 

-static Lisp_Object Flookup_key (Lisp_Object, Lisp_Object, Lisp_Object);

 static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
 
 static Lisp_Object define_as_prefix (Lisp_Object, Lisp_Object);
 static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
 
 static Lisp_Object define_as_prefix (Lisp_Object, Lisp_Object);


@@ -226,7 +225,7 @@ when reading a key-sequence to be looked-up in this keymap.  */)
    Fdefine_key should cause keymaps to be autoloaded.
 
    This function can GC when AUTOLOAD is non-zero, because it calls
    Fdefine_key should cause keymaps to be autoloaded.
 
    This function can GC when AUTOLOAD is non-zero, because it calls

-   do_autoload which can GC.  */
+   Fautoload_do_load which can GC.  */

 
 Lisp_Object
 get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
 
 Lisp_Object
 get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)


@@ -260,7 +259,7 @@ get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
                  struct gcpro gcpro1, gcpro2;
 
                  GCPRO2 (tem, object);
                  struct gcpro gcpro1, gcpro2;
 
                  GCPRO2 (tem, object);

-                 do_autoload (tem, object);
+                 Fautoload_do_load (tem, object, Qnil);

                  UNGCPRO;
 
                  goto autoload_retry;
                  UNGCPRO;
 
                  goto autoload_retry;


@@ -956,8 +955,6 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
   return def;
 }
 
   return def;
 }
 

-static Lisp_Object Fcopy_keymap (Lisp_Object);
-

 static Lisp_Object
 copy_keymap_item (Lisp_Object elt)
 {
 static Lisp_Object
 copy_keymap_item (Lisp_Object elt)
 {


@@ -998,7 +995,7 @@ copy_keymap_item (Lisp_Object elt)
     }
   else
     {
     }
   else
     {

-      /* It may be an old fomat menu item.
+      /* It may be an old format menu item.

         Skip the optional menu string.  */
       if (STRINGP (XCAR (tem)))
        {
         Skip the optional menu string.  */
       if (STRINGP (XCAR (tem)))
        {


@@ -1481,7 +1478,7 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
                /* Use malloc here.  See the comment above this function.
                   Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
                BLOCK_INPUT;
                /* Use malloc here.  See the comment above this function.
                   Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
                BLOCK_INPUT;

-               newmodes = (Lisp_Object *) malloc (allocsize);
+               newmodes = malloc (allocsize);

                if (newmodes)
                  {
                    if (cmm_modes)
                if (newmodes)
                  {
                    if (cmm_modes)


@@ -1493,7 +1490,7 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
                    cmm_modes = newmodes;
                  }
 
                    cmm_modes = newmodes;
                  }
 

-               newmaps = (Lisp_Object *) malloc (allocsize);
+               newmaps = malloc (allocsize);

                if (newmaps)
                  {
                    if (cmm_maps)
                if (newmaps)
                  {
                    if (cmm_maps)


@@ -1563,8 +1560,8 @@ like in the respective argument of `key-binding'. */)
       window = POSN_WINDOW (position);
 
       if (WINDOWP (window)
       window = POSN_WINDOW (position);
 
       if (WINDOWP (window)

-         && BUFFERP (XWINDOW (window)->buffer)
-         && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+         && BUFFERP (WGET (XWINDOW (window), buffer))
+         && XBUFFER (WGET (XWINDOW (window), buffer)) != current_buffer)

        {
          /* Arrange to go back to the original buffer once we're done
             processing the key sequence.  We don't use
        {
          /* Arrange to go back to the original buffer once we're done
             processing the key sequence.  We don't use


@@ -1576,7 +1573,7 @@ like in the respective argument of `key-binding'. */)
 
          record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
 
 
          record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
 

-         set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+         set_buffer_internal (XBUFFER (WGET (XWINDOW (window), buffer)));

        }
     }
 
        }
     }
 


@@ -2013,9 +2010,7 @@ then the value includes only maps for prefixes that start with PREFIX.  */)
        return Qnil;
     }
   else
        return Qnil;
     }
   else

-    maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
-                        get_keymap (keymap, 1, 0)),
-                 Qnil);
+    maps = Fcons (Fcons (zero_vector, get_keymap (keymap, 1, 0)), Qnil);

 
   /* For each map in the list maps,
      look at any other maps it points to,
 
   /* For each map in the list maps,
      look at any other maps it points to,


@@ -2053,8 +2048,9 @@ static Lisp_Object Qsingle_key_description, Qkey_description;
 DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
        doc: /* Return a pretty description of key-sequence KEYS.
 Optional arg PREFIX is the sequence of keys leading up to KEYS.
 DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
        doc: /* Return a pretty description of key-sequence KEYS.
 Optional arg PREFIX is the sequence of keys leading up to KEYS.

-Control characters turn into "C-foo" sequences, meta into "M-foo",
-spaces are put between sequence elements, etc.  */)
+For example, [?\C-x ?l] is converted into the string \"C-x l\".
+
+The `kbd' macro is an approximate inverse of this.  */)

   (Lisp_Object keys, Lisp_Object prefix)
 {
   ptrdiff_t len = 0;
   (Lisp_Object keys, Lisp_Object prefix)
 {
   ptrdiff_t len = 0;


@@ -2073,7 +2069,7 @@ spaces are put between sequence elements, etc.  */)
     size += XINT (Flength (prefix));
 
   /* This has one extra element at the end that we don't pass to Fconcat.  */
     size += XINT (Flength (prefix));
 
   /* This has one extra element at the end that we don't pass to Fconcat.  */

-  if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) / 4 < size)
+  if (min (PTRDIFF_MAX, SIZE_MAX) / word_size / 4 < size)

     memory_full (SIZE_MAX);
   SAFE_ALLOCA_LISP (args, size * 4);
 
     memory_full (SIZE_MAX);
   SAFE_ALLOCA_LISP (args, size * 4);
 


@@ -2145,7 +2141,7 @@ spaces are put between sequence elements, etc.  */)
                continue;
            }
          else
                continue;
            }
          else

-           XSETINT (key, (XINT (key) | meta_modifier) & ~0x80);
+           XSETINT (key, XINT (key) | meta_modifier);

          add_meta = 0;
        }
       else if (EQ (key, meta_prefix_char))
          add_meta = 0;
        }
       else if (EQ (key, meta_prefix_char))


@@ -2288,9 +2284,15 @@ around function keys and event symbols.  */)
   if (CONSP (key) && lucid_event_type_list_p (key))
     key = Fevent_convert_list (key);
 
   if (CONSP (key) && lucid_event_type_list_p (key))
     key = Fevent_convert_list (key);
 

+  if (CONSP (key) && INTEGERP (XCAR (key)) && INTEGERP (XCDR (key)))
+    /* An interval from a map-char-table.  */
+    return concat3 (Fsingle_key_description (XCAR (key), no_angles),
+                   build_string (".."),
+                   Fsingle_key_description (XCDR (key), no_angles));
+

   key = EVENT_HEAD (key);
 
   key = EVENT_HEAD (key);
 

-  if (INTEGERP (key))          /* Normal character */
+  if (INTEGERP (key))          /* Normal character.  */

     {
       char tem[KEY_DESCRIPTION_SIZE], *p;
 
     {
       char tem[KEY_DESCRIPTION_SIZE], *p;
 


@@ -2298,15 +2300,14 @@ around function keys and event symbols.  */)
       *p = 0;
       return make_specified_string (tem, -1, p - tem, 1);
     }
       *p = 0;
       return make_specified_string (tem, -1, p - tem, 1);
     }

-  else if (SYMBOLP (key))      /* Function key or event-symbol */
+  else if (SYMBOLP (key))      /* Function key or event-symbol.  */

     {
       if (NILP (no_angles))
        {
     {
       if (NILP (no_angles))
        {

-         char *buffer;

          Lisp_Object result;
          USE_SAFE_ALLOCA;
          Lisp_Object result;
          USE_SAFE_ALLOCA;

-         SAFE_ALLOCA (buffer, char *,
-                      sizeof "<>" + SBYTES (SYMBOL_NAME (key)));
+         char *buffer = SAFE_ALLOCA (sizeof "<>"
+                                     + SBYTES (SYMBOL_NAME (key)));

          esprintf (buffer, "<%s>", SDATA (SYMBOL_NAME (key)));
          result = build_string (buffer);
          SAFE_FREE ();
          esprintf (buffer, "<%s>", SDATA (SYMBOL_NAME (key)));
          result = build_string (buffer);
          SAFE_FREE ();


@@ -2564,7 +2565,8 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
        doc: /* Return list of keys that invoke DEFINITION.
 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
        doc: /* Return list of keys that invoke DEFINITION.
 If KEYMAP is a keymap, search only KEYMAP and the global keymap.

-If KEYMAP is nil, search all the currently active keymaps.
+If KEYMAP is nil, search all the currently active keymaps, except
+ for `overriding-local-map' (which is ignored).

 If KEYMAP is a list of keymaps, search only those keymaps.
 
 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
 If KEYMAP is a list of keymaps, search only those keymaps.
 
 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,


@@ -2579,9 +2581,17 @@ If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
 to other keymaps or slots.  This makes it possible to search for an
 indirect definition itself.
 
 to other keymaps or slots.  This makes it possible to search for an
 indirect definition itself.
 

-If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
-that invoke a command which is remapped to DEFINITION, but include the
-remapped command in the returned list.  */)
+The optional 5th arg NO-REMAP alters how command remapping is handled:
+
+- If another command OTHER-COMMAND is remapped to DEFINITION, normally
+  search for the bindings of OTHER-COMMAND and include them in the
+  returned list.  But if NO-REMAP is non-nil, include the vector
+  [remap OTHER-COMMAND] in the returned list instead, without
+  searching for those other bindings.
+
+- If DEFINITION is remapped to OTHER-COMMAND, normally return the
+  bindings for OTHER-COMMAND.  But if NO-REMAP is non-nil, return the
+  bindings for DEFINITION instead, ignoring its remapping.  */)

   (Lisp_Object definition, Lisp_Object keymap, Lisp_Object firstonly, Lisp_Object noindirect, Lisp_Object no_remap)
 {
   /* The keymaps in which to search.  */
   (Lisp_Object definition, Lisp_Object keymap, Lisp_Object firstonly, Lisp_Object noindirect, Lisp_Object no_remap)
 {
   /* The keymaps in which to search.  */


@@ -2642,11 +2652,11 @@ remapped command in the returned list.  */)
       /* We have a list of advertised bindings.  */
       while (CONSP (tem))
        if (EQ (shadow_lookup (keymaps, XCAR (tem), Qnil, 0), definition))
       /* We have a list of advertised bindings.  */
       while (CONSP (tem))
        if (EQ (shadow_lookup (keymaps, XCAR (tem), Qnil, 0), definition))

-         return XCAR (tem);
+         RETURN_UNGCPRO (XCAR (tem));

        else
          tem = XCDR (tem);
       if (EQ (shadow_lookup (keymaps, tem, Qnil, 0), definition))
        else
          tem = XCDR (tem);
       if (EQ (shadow_lookup (keymaps, tem, Qnil, 0), definition))

-       return tem;
+       RETURN_UNGCPRO (tem);

     }
 
   sequences = Freverse (where_is_internal (definition, keymaps,
     }
 
   sequences = Freverse (where_is_internal (definition, keymaps,


@@ -2910,7 +2920,7 @@ You type        Translation\n\
          if (!SYMBOLP (modes[i]))
            abort ();
 
          if (!SYMBOLP (modes[i]))
            abort ();
 

-         p = title = (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes[i])));
+         p = title = alloca (42 + SCHARS (SYMBOL_NAME (modes[i])));

          *p++ = '\f';
          *p++ = '\n';
          *p++ = '`';
          *p++ = '\f';
          *p++ = '\n';
          *p++ = '`';


@@ -2980,9 +2990,9 @@ You type        Translation\n\
    If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
    don't omit it; instead, mention it but say it is shadowed.
 
    If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
    don't omit it; instead, mention it but say it is shadowed.
 

-   Return whether something was inserted or not.  */
+   Any inserted text ends in two newlines (used by `help-make-xrefs').  */

 
 

-int
+void

 describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
                   Lisp_Object prefix, const char *title, int nomenu, int transl,
                   int always_title, int mention_shadow)
 describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
                   Lisp_Object prefix, const char *title, int nomenu, int transl,
                   int always_title, int mention_shadow)


@@ -3092,8 +3102,10 @@ key             binding\n\
     skip: ;
     }
 
     skip: ;
     }
 

+  if (something)
+    insert_string ("\n");
+

   UNGCPRO;
   UNGCPRO;

-  return something;

 }
 
 static int previous_description_column;
 }
 
 static int previous_description_column;


@@ -3689,13 +3701,12 @@ syms_of_keymap (void)
   Fset (intern_c_string ("ctl-x-map"), control_x_map);
   Ffset (intern_c_string ("Control-X-prefix"), control_x_map);
 
   Fset (intern_c_string ("ctl-x-map"), control_x_map);
   Ffset (intern_c_string ("Control-X-prefix"), control_x_map);
 

-  exclude_keys
-    = pure_cons (pure_cons (make_pure_c_string ("DEL"), make_pure_c_string ("\\d")),
-                pure_cons (pure_cons (make_pure_c_string ("TAB"), make_pure_c_string ("\\t")),
-                   pure_cons (pure_cons (make_pure_c_string ("RET"), make_pure_c_string ("\\r")),
-                          pure_cons (pure_cons (make_pure_c_string ("ESC"), make_pure_c_string ("\\e")),
-                                 pure_cons (pure_cons (make_pure_c_string ("SPC"), make_pure_c_string (" ")),
-                                        Qnil)))));
+  exclude_keys = listn (CONSTYPE_PURE, 5,
+                       pure_cons (build_pure_c_string ("DEL"), build_pure_c_string ("\\d")),
+                       pure_cons (build_pure_c_string ("TAB"), build_pure_c_string ("\\t")),
+                       pure_cons (build_pure_c_string ("RET"), build_pure_c_string ("\\r")),
+                       pure_cons (build_pure_c_string ("ESC"), build_pure_c_string ("\\e")),
+                       pure_cons (build_pure_c_string ("SPC"), build_pure_c_string (" ")));

   staticpro (&exclude_keys);
 
   DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands,
   staticpro (&exclude_keys);
 
   DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands,


@@ -3748,16 +3759,16 @@ be preferred.  */);
   where_is_preferred_modifier = 0;
 
   staticpro (&Vmouse_events);
   where_is_preferred_modifier = 0;
 
   staticpro (&Vmouse_events);

-  Vmouse_events = pure_cons (intern_c_string ("menu-bar"),
-                 pure_cons (intern_c_string ("tool-bar"),
-                 pure_cons (intern_c_string ("header-line"),
-                 pure_cons (intern_c_string ("mode-line"),
-                 pure_cons (intern_c_string ("mouse-1"),
-                 pure_cons (intern_c_string ("mouse-2"),
-                 pure_cons (intern_c_string ("mouse-3"),
-                 pure_cons (intern_c_string ("mouse-4"),
-                 pure_cons (intern_c_string ("mouse-5"),
-                            Qnil)))))))));
+  Vmouse_events = listn (CONSTYPE_PURE, 9,
+                        intern_c_string ("menu-bar"),
+                        intern_c_string ("tool-bar"),
+                        intern_c_string ("header-line"),
+                        intern_c_string ("mode-line"),
+                        intern_c_string ("mouse-1"),
+                        intern_c_string ("mouse-2"),
+                        intern_c_string ("mouse-3"),
+                        intern_c_string ("mouse-4"),
+                        intern_c_string ("mouse-5"));

 
   DEFSYM (Qsingle_key_description, "single-key-description");
   DEFSYM (Qkey_description, "key-description");
 
   DEFSYM (Qsingle_key_description, "single-key-description");
   DEFSYM (Qkey_description, "key-description");