X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/2b30549c493d7b67fa92c2b4bcd2bd2e55210ae1..a5c9bbb3413d8eea89cb832040a0ef6cd704dcfe:/src/keymap.c diff --git a/src/keymap.c b/src/keymap.c index f64c8d5a84..562787ee8a 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -56,28 +56,28 @@ along with GNU Emacs. If not, see . */ #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,14 +571,14 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val) { if (!NILP (val)) { - map_keymap_function_t fun = XSAVE_POINTER (XCAR (args), 0); - args = XCDR (args); + 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)) key = Fcons (XCAR (key), XCDR (key)); - map_keymap_item (fun, XCDR (args), key, val, - XSAVE_POINTER (XCAR (args), 0)); + map_keymap_item (fun, XSAVE_OBJECT (args, 2), key, + val, XSAVE_POINTER (args, 1)); } } @@ -610,12 +616,9 @@ map_keymap_internal (Lisp_Object map, } } else if (CHAR_TABLE_P (binding)) - { - map_char_table (map_keymap_char_table_item, Qnil, binding, - Fcons (make_save_value ((void *) fun, 0), - Fcons (make_save_value (data, 0), - args))); - } + map_char_table (map_keymap_char_table_item, Qnil, binding, + make_save_funcptr_ptr_obj ((voidfuncptr) fun, data, + args)); } UNGCPRO; return tail; @@ -1042,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)) @@ -1070,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); } @@ -1249,7 +1252,7 @@ remapping in all currently active keymaps. */) return INTEGERP (command) ? Qnil : command; } -/* Value is number if KEY is too long; nil if valid but has no definition. */ +/* Value is number if KEY is too long; nil if valid but has no definition. */ /* GC is possible in this function. */ DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0, @@ -1338,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,16 +1543,16 @@ DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps, doc: /* Return a list of the currently active keymaps. OLP if non-nil indicates that we should obey `overriding-local-map' and `overriding-terminal-local-map'. POSITION can specify a click position -like in the respective argument of `key-binding'. */) +like in the respective argument of `key-binding'. */) (Lisp_Object olp, Lisp_Object position) { 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 - switch the buffer here. */ + switch the buffer here. */ if (CONSP (position)) { @@ -1559,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 @@ -1570,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; @@ -1595,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)) { @@ -1659,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); @@ -1805,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; @@ -1947,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))); } } @@ -2001,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, @@ -2315,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 * @@ -2616,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); @@ -2855,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)); } @@ -2871,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; @@ -3239,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)) { @@ -3374,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); } }