/* Manipulation of keymaps
- Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1992 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
+#include "keyboard.h"
+#include "termhooks.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
-/* Dense keymaps look like (keymap VECTOR . ALIST), where VECTOR is a
- 128-element vector used to look up bindings for ASCII characters,
- and ALIST is an assoc list for looking up symbols. */
+/* The number of elements in keymap vectors. */
#define DENSE_TABLE_SIZE (0200)
/* Actually allocate storage for these variables */
/* was MinibufLocalMustMatchMap */
Lisp_Object Vminibuffer_local_must_match_map;
+/* Alist of minor mode variables and keymaps. */
+Lisp_Object Vminor_mode_map_alist;
+
+/* Keymap mapping ASCII function key sequences onto their preferred forms.
+ Initialized by the terminal-specific lisp files. See DEFVAR for more
+ documentation. */
+Lisp_Object Vfunction_key_map;
+
Lisp_Object Qkeymapp, Qkeymap;
/* A char over 0200 in a key sequence
static Lisp_Object describe_buffer_bindings ();
static void describe_command ();
static void describe_map ();
-static void describe_alist ();
+static void describe_map_2 ();
\f
-DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 0, 0,
+/* Keymap object support - constructors and predicates. */
+
+DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,
"Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
VECTOR is a 128-element vector which holds the bindings for the ASCII\n\
characters. ALIST is an assoc-list which holds bindings for function keys,\n\
mouse events, and any other things that appear in the input stream.\n\
-All entries in it are initially nil, meaning \"command undefined\".")
- ()
+All entries in it are initially nil, meaning \"command undefined\".\n\n\
+The optional arg STRING supplies a menu name for the keymap\n\
+in case you use it as a menu with `x-popup-menu'.")
+ (string)
+ Lisp_Object string;
{
+ Lisp_Object tail;
+ if (!NILP (string))
+ tail = Fcons (string, Qnil);
+ else
+ tail = Qnil;
return Fcons (Qkeymap,
Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE), Qnil),
- Qnil));
+ tail));
}
-DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 0, 0,
+DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
"Construct and return a new sparse-keymap list.\n\
Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
which binds the function key or mouse event SYMBOL to DEFINITION.\n\
-Initially the alist is nil.")
- ()
+Initially the alist is nil.\n\n\
+The optional arg STRING supplies a menu name for the keymap\n\
+in case you use it as a menu with `x-popup-menu'.")
+ (string)
+ Lisp_Object string;
{
+ if (!NILP (string))
+ return Fcons (Qkeymap, Fcons (string, Qnil));
return Fcons (Qkeymap, Qnil);
}
For example:
- initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark");
-
- I haven't extended these to allow the initializing code to bind
- function keys and mouse events; since they are called by many files,
- I'd have to fix lots of callers, and nobody right now would be using
- the new functionality, so it seems like a waste of time. But there's
- no technical reason not to. -JimB */
+ initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
void
initial_define_key (keymap, key, defname)
store_in_keymap (keymap, make_number (key), intern (defname));
}
+void
+initial_define_lispy_key (keymap, keyname, defname)
+ Lisp_Object keymap;
+ char *keyname;
+ char *defname;
+{
+ store_in_keymap (keymap, intern (keyname), intern (defname));
+}
+
/* Define character fromchar in map frommap as an alias for character
tochar in map tomap. Subsequent redefinitions of the latter WILL
affect the former. */
(object)
Lisp_Object object;
{
- return (NULL (get_keymap_1 (object, 0)) ? Qnil : Qt);
+ return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
}
/* Check that OBJECT is a keymap (after dereferencing through any
- symbols). If it is, return it; otherwise, return nil, or signal an
- error if ERROR != 0. */
+ symbols). If it is, return it.
+
+ If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
+ is an autoload form, do the autoload and try again.
+
+ ERROR controls how we respond if OBJECT isn't a keymap.
+ If ERROR is non-zero, signal an error; otherwise, just return Qnil.
+
+ Note that most of the time, we don't want to pursue autoloads.
+ Functions like Faccessible_keymaps which scan entire keymap trees
+ shouldn't load every autoloaded keymap. I'm not sure about this,
+ but it seems to me that only read_key_sequence, Flookup_key, and
+ Fdefine_key should cause keymaps to be autoloaded. */
+
Lisp_Object
-get_keymap_1 (object, error)
+get_keymap_1 (object, error, autoload)
Lisp_Object object;
- int error;
+ int error, autoload;
{
- register Lisp_Object tem;
+ Lisp_Object tem;
- tem = object;
- while (XTYPE (tem) == Lisp_Symbol && !EQ (tem, Qunbound))
- {
- tem = XSYMBOL (tem)->function;
- QUIT;
- }
+ autoload_retry:
+ tem = indirect_function (object);
if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
return tem;
+
+ /* Should we do an autoload? Autoload forms for keymaps have
+ Qkeymap as their fifth element. */
+ if (autoload
+ && XTYPE (object) == Lisp_Symbol
+ && CONSP (tem)
+ && EQ (XCONS (tem)->car, Qautoload))
+ {
+ Lisp_Object tail;
+
+ tail = Fnth (make_number (4), tem);
+ if (EQ (tail, Qkeymap))
+ {
+ struct gcpro gcpro1, gcpro2;
+
+ GCPRO2 (tem, object)
+ do_autoload (tem, object);
+ UNGCPRO;
+
+ goto autoload_retry;
+ }
+ }
+
if (error)
wrong_type_argument (Qkeymapp, object);
- else return Qnil;
+ else
+ return Qnil;
}
+
+/* Follow any symbol chaining, and return the keymap denoted by OBJECT.
+ If OBJECT doesn't denote a keymap at all, signal an error. */
Lisp_Object
get_keymap (object)
Lisp_Object object;
{
- return get_keymap_1 (object, 1);
+ return get_keymap_1 (object, 0, 0);
}
-/* If KEYMAP is a dense keymap, return the vector from its cadr.
- Otherwise, return nil. */
-
-static Lisp_Object
-keymap_table (keymap)
- Lisp_Object keymap;
-{
- Lisp_Object cadr;
-
- if (CONSP (XCONS (keymap)->cdr)
- && XTYPE (cadr = XCONS (XCONS (keymap)->cdr)->car) == Lisp_Vector
- && XVECTOR (cadr)->size == DENSE_TABLE_SIZE)
- return cadr;
- else
- return Qnil;
-}
+/* Look up IDX in MAP. IDX may be any sort of event.
+ Note that this does only one level of lookup; IDX must be a single
+ event, not a sequence.
+ If T_OK is non-zero, bindings for Qt are treated as default
+ bindings; any key left unmentioned by other tables and bindings is
+ given the binding of Qt.
-/* Look up IDX in MAP. IDX may be any sort of event.
- Note that this does only one level of lookup; IDX must
- be a single event, not a sequence. */
+ If T_OK is zero, bindings for Qt are not treated specially. */
Lisp_Object
-access_keymap (map, idx)
+access_keymap (map, idx, t_ok)
Lisp_Object map;
Lisp_Object idx;
+ int t_ok;
{
/* If idx is a list (some sort of mouse click, perhaps?),
the index we want to use is the car of the list, which
ought to be a symbol. */
- if (XTYPE (idx) == Lisp_Cons)
- idx = XCONS (idx)->car;
+ idx = EVENT_HEAD (idx);
- if (XTYPE (idx) == Lisp_Int
- && (XINT (idx) < 0 || XINT (idx) >= DENSE_TABLE_SIZE))
- error ("Command key is not an ASCII character");
+ /* If idx is a symbol, it might have modifiers, which need to
+ be put in the canonical order. */
+ if (XTYPE (idx) == Lisp_Symbol)
+ idx = reorder_modifiers (idx);
{
- Lisp_Object table = keymap_table (map);
+ Lisp_Object tail;
+ Lisp_Object t_binding = Qnil;
- /* A dense keymap indexed by a character? */
- if (XTYPE (idx) == Lisp_Int
- && ! NULL (table))
- return XVECTOR (table)->contents[XFASTINT (idx)];
-
- /* This lookup will not involve a vector reference. */
- else
+ for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
{
- /* If idx is a symbol, it might have modifiers, which need to
- be put in the canonical order. */
- if (XTYPE (idx) == Lisp_Symbol)
- idx = reorder_modifiers (idx);
-
- return Fcdr (Fassq (idx, map));
+ Lisp_Object binding = XCONS (tail)->car;
+
+ switch (XTYPE (binding))
+ {
+ case Lisp_Cons:
+ if (EQ (XCONS (binding)->car, idx))
+ return XCONS (binding)->cdr;
+ if (t_ok && EQ (XCONS (binding)->car, Qt))
+ t_binding = XCONS (binding)->cdr;
+ break;
+
+ case Lisp_Vector:
+ if (XVECTOR (binding)->size == DENSE_TABLE_SIZE
+ && XTYPE (idx) == Lisp_Int
+ && XINT (idx) >= 0
+ && XINT (idx) < DENSE_TABLE_SIZE)
+ return XVECTOR (binding)->contents[XINT (idx)];
+ break;
+ }
+
+ QUIT;
}
+
+ return t_binding;
}
}
and INDEX is the object to look up in KEYMAP to yield the definition.
Also if OBJECT has a menu string as the first element,
- remove that. */
+ remove that. Also remove a menu help string as second element. */
Lisp_Object
get_keyelt (object)
{
register Lisp_Object map, tem;
- map = get_keymap_1 (Fcar_safe (object), 0);
- tem = Fkeymapp (map);
-
/* If the contents are (KEYMAP . ELEMENT), go indirect. */
- if (!NULL (tem))
- object = access_keymap (map, Fcdr (object));
+ map = get_keymap_1 (Fcar_safe (object), 0, 0);
+ tem = Fkeymapp (map);
+ if (!NILP (tem))
+ object = access_keymap (map, Fcdr (object), 0);
/* If the keymap contents looks like (STRING . DEFN),
use DEFN.
will be used by HierarKey menus. */
else if (XTYPE (object) == Lisp_Cons
&& XTYPE (XCONS (object)->car) == Lisp_String)
- object = XCONS (object)->cdr;
+ {
+ object = XCONS (object)->cdr;
+ /* Also remove a menu help string, if any,
+ following the menu item name. */
+ if (XTYPE (object) == Lisp_Cons
+ && XTYPE (XCONS (object)->car) == Lisp_String)
+ object = XCONS (object)->cdr;
+ }
else
/* Anything else is really the value. */
register Lisp_Object idx;
register Lisp_Object def;
{
+ if (XTYPE (keymap) != Lisp_Cons
+ || ! EQ (XCONS (keymap)->car, Qkeymap))
+ error ("attempt to define a key in a non-keymap");
+
/* If idx is a list (some sort of mouse click, perhaps?),
the index we want to use is the car of the list, which
ought to be a symbol. */
- if (XTYPE (idx) == Lisp_Cons)
- idx = Fcar (idx);
+ idx = EVENT_HEAD (idx);
- if (XTYPE (idx) == Lisp_Int
- && (XINT (idx) < 0 || XINT (idx) >= DENSE_TABLE_SIZE))
- error ("Command key is a character outside of the ASCII set.");
-
+ /* If idx is a symbol, it might have modifiers, which need to
+ be put in the canonical order. */
+ if (XTYPE (idx) == Lisp_Symbol)
+ idx = reorder_modifiers (idx);
+
+
+ /* Scan the keymap for a binding of idx. */
{
- Lisp_Object table = keymap_table (keymap);
+ Lisp_Object tail;
- /* A dense keymap indexed by a character? */
- if (XTYPE (idx) == Lisp_Int && !NULL (table))
- XVECTOR (table)->contents[XFASTINT (idx)] = def;
+ /* The cons after which we should insert new bindings. If the
+ keymap has a table element, we record its position here, so new
+ bindings will go after it; this way, the table will stay
+ towards the front of the alist and character lookups in dense
+ keymaps will remain fast. Otherwise, this just points at the
+ front of the keymap. */
+ Lisp_Object insertion_point = keymap;
- /* Must be a sparse keymap, or a dense keymap indexed by a symbol. */
- else
+ for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
{
- /* Point to the pointer to the start of the assoc-list part
- of the keymap. */
- register Lisp_Object *assoc_head
- = (NULL (table)
- ? & XCONS (keymap)->cdr
- : & XCONS (XCONS (keymap)->cdr)->cdr);
- register Lisp_Object defining_pair;
-
- /* If idx is a symbol, it might have modifiers, which need to
- be put in the canonical order. */
- if (XTYPE (idx) == Lisp_Symbol)
- idx = reorder_modifiers (idx);
-
- /* Point to the pair where idx is bound, if any. */
- defining_pair = Fassq (idx, *assoc_head);
-
- if (NULL (defining_pair))
- *assoc_head = Fcons (Fcons (idx, def), *assoc_head);
- else
- Fsetcdr (defining_pair, def);
+ Lisp_Object elt = XCONS (tail)->car;
+
+ switch (XTYPE (elt))
+ {
+ case Lisp_Vector:
+ if (XVECTOR (elt)->size != DENSE_TABLE_SIZE)
+ break;
+ if (XTYPE (idx) == Lisp_Int
+ && XINT (idx) >= 0 && XINT (idx) < DENSE_TABLE_SIZE)
+ {
+ XVECTOR (elt)->contents[XFASTINT (idx)] = def;
+ return def;
+ }
+ insertion_point = tail;
+ break;
+
+ case Lisp_Cons:
+ if (EQ (idx, XCONS (elt)->car))
+ {
+ XCONS (elt)->cdr = def;
+ return def;
+ }
+ break;
+
+ case Lisp_Symbol:
+ /* If we find a 'keymap' symbol in the spine of KEYMAP,
+ then we must have found the start of a second keymap
+ being used as the tail of KEYMAP, and a binding for IDX
+ should be inserted before it. */
+ if (EQ (elt, Qkeymap))
+ goto keymap_end;
+ break;
+ }
+
+ QUIT;
}
- }
+ keymap_end:
+ /* We have scanned the entire keymap, and not found a binding for
+ IDX. Let's add one. */
+ XCONS (insertion_point)->cdr =
+ Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr);
+ }
+
return def;
}
+
DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
"Return a copy of the keymap KEYMAP.\n\
The copy starts out with the same definitions of KEYMAP,\n\
register Lisp_Object copy, tail;
copy = Fcopy_alist (get_keymap (keymap));
- tail = XCONS (copy)->cdr;
- /* If this is a dense keymap, copy the vector. */
- if (CONSP (tail))
+ for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
{
- register Lisp_Object table = XCONS (tail)->car;
+ Lisp_Object elt = XCONS (tail)->car;
- if (XTYPE (table) == Lisp_Vector
- && XVECTOR (table)->size == DENSE_TABLE_SIZE)
+ if (XTYPE (elt) == Lisp_Vector
+ && XVECTOR (elt)->size == DENSE_TABLE_SIZE)
{
- register int i;
+ int i;
- table = Fcopy_sequence (table);
+ elt = Fcopy_sequence (elt);
+ XCONS (tail)->car = elt;
for (i = 0; i < DENSE_TABLE_SIZE; i++)
- if (XTYPE (XVECTOR (copy)->contents[i]) != Lisp_Symbol)
- if (! NULL (Fkeymapp (XVECTOR (table)->contents[i])))
- XVECTOR (table)->contents[i]
- = Fcopy_keymap (XVECTOR (table)->contents[i]);
- XCONS (tail)->car = table;
-
- tail = XCONS (tail)->cdr;
+ if (XTYPE (XVECTOR (elt)->contents[i]) != Lisp_Symbol
+ && Fkeymapp (XVECTOR (elt)->contents[i]))
+ XVECTOR (elt)->contents[i] =
+ Fcopy_keymap (XVECTOR (elt)->contents[i]);
}
- }
-
- /* Copy the alist portion of the keymap. */
- while (CONSP (tail))
- {
- register Lisp_Object elt;
-
- elt = XCONS (tail)->car;
- if (CONSP (elt)
- && XTYPE (XCONS (elt)->cdr) != Lisp_Symbol
- && ! NULL (Fkeymapp (XCONS (elt)->cdr)))
+ else if (CONSP (elt)
+ && XTYPE (XCONS (elt)->cdr) != Lisp_Symbol
+ && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
-
- tail = XCONS (tail)->cdr;
}
return copy;
}
\f
+/* Simple Keymap mutators and accessors. */
+
DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
"Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
the front of KEYMAP.")
(keymap, key, def)
- register Lisp_Object keymap;
+ Lisp_Object keymap;
Lisp_Object key;
Lisp_Object def;
{
register Lisp_Object tem;
register Lisp_Object cmd;
int metized = 0;
+ int meta_bit;
int length;
+ struct gcpro gcpro1, gcpro2, gcpro3;
keymap = get_keymap (keymap);
&& XTYPE (key) != Lisp_String)
key = wrong_type_argument (Qarrayp, key);
- length = Flength (key);
+ length = XFASTINT (Flength (key));
if (length == 0)
return Qnil;
+ GCPRO3 (keymap, key, def);
+
+ if (XTYPE (key) == Lisp_Vector)
+ meta_bit = meta_modifier;
+ else
+ meta_bit = 0x80;
+
idx = 0;
while (1)
{
c = Faref (key, make_number (idx));
if (XTYPE (c) == Lisp_Int
- && XINT (c) >= 0200
+ && (XINT (c) & meta_bit)
&& !metized)
{
c = meta_prefix_char;
else
{
if (XTYPE (c) == Lisp_Int)
- XSETINT (c, XINT (c) & 0177);
+ XSETINT (c, XINT (c) & ~meta_bit);
metized = 0;
idx++;
}
if (idx == length)
- return store_in_keymap (keymap, c, def);
+ RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
- cmd = get_keyelt (access_keymap (keymap, c));
+ cmd = get_keyelt (access_keymap (keymap, c, 0));
- if (NULL (cmd))
+ if (NILP (cmd))
{
- cmd = Fmake_sparse_keymap ();
+ cmd = Fmake_sparse_keymap (Qnil);
store_in_keymap (keymap, c, cmd);
}
- tem = Fkeymapp (cmd);
- if (NULL (tem))
- error ("Key sequence %s uses invalid prefix characters",
- XSTRING (key)->data);
+ keymap = get_keymap_1 (cmd, 0, 1);
+ if (NILP (keymap))
+ {
+ /* We must use Fkey_description rather than just passing key to
+ error; key might be a vector, not a string. */
+ Lisp_Object description = Fkey_description (key);
- keymap = get_keymap (cmd);
+ error ("Key sequence %s uses invalid prefix characters",
+ XSTRING (description)->data);
+ }
}
}
/* Value is number if KEY is too long; NIL if valid but has no definition. */
-DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 2, 0,
+DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
"In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
nil means undefined. See doc of `define-key' for kinds of definitions.\n\
+\n\
A number as value means KEY is \"too long\";\n\
that is, characters or symbols in it except for the last one\n\
fail to be a valid sequence of prefix characters in KEYMAP.\n\
The number is how many characters at the front of KEY\n\
-it takes to reach a non-prefix command.")
- (keymap, key)
+it takes to reach a non-prefix command.\n\
+\n\
+Normally, `lookup-key' ignores bindings for t, which act as default\n\
+bindings, used when nothing else in the keymap applies; this makes it\n\
+useable as a general function for probing keymaps. However, if the\n\
+third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
+recognize the default bindings, just as `read-key-sequence' does.")
+ (keymap, key, accept_default)
register Lisp_Object keymap;
Lisp_Object key;
+ Lisp_Object accept_default;
{
register int idx;
register Lisp_Object tem;
register Lisp_Object c;
int metized = 0;
int length;
+ int t_ok = ! NILP (accept_default);
+ int meta_bit;
keymap = get_keymap (keymap);
&& XTYPE (key) != Lisp_String)
key = wrong_type_argument (Qarrayp, key);
- length = Flength (key);
+ length = XFASTINT (Flength (key));
if (length == 0)
return keymap;
+ if (XTYPE (key) == Lisp_Vector)
+ meta_bit = meta_modifier;
+ else
+ meta_bit = 0x80;
+
idx = 0;
while (1)
{
c = Faref (key, make_number (idx));
if (XTYPE (c) == Lisp_Int
- && XINT (c) >= 0200
+ && (XINT (c) & meta_bit)
&& !metized)
{
c = meta_prefix_char;
else
{
if (XTYPE (c) == Lisp_Int)
- XSETINT (c, XINT (c) & 0177);
+ XSETINT (c, XINT (c) & ~meta_bit);
metized = 0;
idx++;
}
- cmd = get_keyelt (access_keymap (keymap, c));
+ cmd = get_keyelt (access_keymap (keymap, c, t_ok));
if (idx == length)
return cmd;
- tem = Fkeymapp (cmd);
- if (NULL (tem))
+ keymap = get_keymap_1 (cmd, 0, 0);
+ if (NILP (keymap))
return make_number (idx);
- keymap = get_keymap (cmd);
QUIT;
}
}
-/* Append a key to the end of a key sequence. If key_sequence is a
- string and key is a character, the result will be another string;
- otherwise, it will be a vector. */
+/* Append a key to the end of a key sequence. We always make a vector. */
+
Lisp_Object
append_key (key_sequence, key)
Lisp_Object key_sequence, key;
args[0] = key_sequence;
- if (XTYPE (key_sequence) == Lisp_String
- && XTYPE (key) == Lisp_Int)
- {
- args[1] = Fchar_to_string (key);
- return Fconcat (2, args);
- }
- else
- {
- args[1] = Fcons (key, Qnil);
- return Fvconcat (2, args);
- }
+ args[1] = Fcons (key, Qnil);
+ return Fvconcat (2, args);
}
\f
-DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 1, 0,
+/* Global, local, and minor mode keymap stuff. */
+
+/* We can't put these variables inside current_minor_maps, since under
+ some systems, static gets macro-defined to be the empty string.
+ Ickypoo. */
+static Lisp_Object *cmm_modes, *cmm_maps;
+static int cmm_size;
+
+/* Store a pointer to an array of the keymaps of the currently active
+ minor modes in *buf, and return the number of maps it contains.
+
+ This function always returns a pointer to the same buffer, and may
+ free or reallocate it, so if you want to keep it for a long time or
+ hand it out to lisp code, copy it. This procedure will be called
+ for every key sequence read, so the nice lispy approach (return a
+ new assoclist, list, what have you) for each invocation would
+ result in a lot of consing over time.
+
+ If we used xrealloc/xmalloc and ran out of memory, they would throw
+ back to the command loop, which would try to read a key sequence,
+ which would call this function again, resulting in an infinite
+ loop. Instead, we'll use realloc/malloc and silently truncate the
+ list, let the key sequence be read, and hope some other piece of
+ code signals the error. */
+int
+current_minor_maps (modeptr, mapptr)
+ Lisp_Object **modeptr, **mapptr;
+{
+ int i = 0;
+ Lisp_Object alist, assoc, var, val;
+
+ for (alist = Vminor_mode_map_alist;
+ CONSP (alist);
+ alist = XCONS (alist)->cdr)
+ if (CONSP (assoc = XCONS (alist)->car)
+ && XTYPE (var = XCONS (assoc)->car) == Lisp_Symbol
+ && ! EQ ((val = find_symbol_value (var)), Qunbound)
+ && ! NILP (val))
+ {
+ if (i >= cmm_size)
+ {
+ Lisp_Object *newmodes, *newmaps;
+
+ if (cmm_maps)
+ {
+ newmodes = (Lisp_Object *) realloc (cmm_modes, cmm_size *= 2);
+ newmaps = (Lisp_Object *) realloc (cmm_maps, cmm_size);
+ }
+ else
+ {
+ newmodes = (Lisp_Object *) malloc (cmm_size = 30);
+ newmaps = (Lisp_Object *) malloc (cmm_size);
+ }
+
+ if (newmaps && newmodes)
+ {
+ cmm_modes = newmodes;
+ cmm_maps = newmaps;
+ }
+ else
+ break;
+ }
+ cmm_modes[i] = var;
+ cmm_maps [i] = XCONS (assoc)->cdr;
+ i++;
+ }
+
+ if (modeptr) *modeptr = cmm_modes;
+ if (mapptr) *mapptr = cmm_maps;
+ return i;
+}
+
+DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
"Return the binding for command KEY in current keymaps.\n\
-KEY is a string, a sequence of keystrokes.\n\
-The binding is probably a symbol with a function definition.")
- (key)
+KEY is a string or vector, a sequence of keystrokes.\n\
+The binding is probably a symbol with a function definition.\n\
+\n\
+Normally, `key-binding' ignores bindings for t, which act as default\n\
+bindings, used when nothing else in the keymap applies; this makes it\n\
+useable as a general function for probing keymaps. However, if the\n\
+third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\
+recognize the default bindings, just as `read-key-sequence' does.")
+ (key, accept_default)
Lisp_Object key;
{
- register Lisp_Object map, value, value1;
- map = current_buffer->keymap;
- if (!NULL (map))
+ Lisp_Object *maps, value;
+ int nmaps, i;
+
+ nmaps = current_minor_maps (0, &maps);
+ for (i = 0; i < nmaps; i++)
+ if (! NILP (maps[i]))
+ {
+ value = Flookup_key (maps[i], key, accept_default);
+ if (! NILP (value) && XTYPE (value) != Lisp_Int)
+ return value;
+ }
+
+ if (! NILP (current_buffer->keymap))
{
- value = Flookup_key (map, key);
- if (NULL (value))
- {
- value1 = Flookup_key (current_global_map, key);
- if (XTYPE (value1) == Lisp_Int)
- return Qnil;
- return value1;
- }
- else if (XTYPE (value) != Lisp_Int)
+ value = Flookup_key (current_buffer->keymap, key, accept_default);
+ if (! NILP (value) && XTYPE (value) != Lisp_Int)
return value;
}
- return Flookup_key (current_global_map, key);
+
+ value = Flookup_key (current_global_map, key, accept_default);
+ if (! NILP (value) && XTYPE (value) != Lisp_Int)
+ return value;
+
+ return Qnil;
}
-DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 1, 0,
+DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
"Return the binding for command KEYS in current local keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
-The binding is probably a symbol with a function definition.")
- (keys)
- Lisp_Object keys;
+The binding is probably a symbol with a function definition.\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (keys, accept_default)
+ Lisp_Object keys, accept_default;
{
register Lisp_Object map;
map = current_buffer->keymap;
- if (NULL (map))
+ if (NILP (map))
return Qnil;
- return Flookup_key (map, keys);
+ return Flookup_key (map, keys, accept_default);
}
-DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 1, 0,
+DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
"Return the binding for command KEYS in current global keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
-The binding is probably a symbol with a function definition.")
- (keys)
- Lisp_Object keys;
+The binding is probably a symbol with a function definition.\n\
+This function's return values are the same as those of lookup-key\n\
+(which see).\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (keys, accept_default)
+ Lisp_Object keys, accept_default;
{
- return Flookup_key (current_global_map, keys);
+ return Flookup_key (current_global_map, keys, accept_default);
+}
+
+DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
+ "Find the visible minor mode bindings of KEY.\n\
+Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
+the symbol which names the minor mode binding KEY, and BINDING is\n\
+KEY's definition in that mode. In particular, if KEY has no\n\
+minor-mode bindings, return nil. If the first binding is a\n\
+non-prefix, all subsequent bindings will be omitted, since they would\n\
+be ignored. Similarly, the list doesn't include non-prefix bindings\n\
+that come after prefix bindings.\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (key, accept_default)
+ Lisp_Object key, accept_default;
+{
+ Lisp_Object *modes, *maps;
+ int nmaps;
+ Lisp_Object binding;
+ int i, j;
+
+ nmaps = current_minor_maps (&modes, &maps);
+
+ for (i = j = 0; i < nmaps; i++)
+ if (! NILP (maps[i])
+ && ! NILP (binding = Flookup_key (maps[i], key, accept_default))
+ && XTYPE (binding) != Lisp_Int)
+ {
+ if (! NILP (get_keymap (binding)))
+ maps[j++] = Fcons (modes[i], binding);
+ else if (j == 0)
+ return Fcons (Fcons (modes[i], binding), Qnil);
+ }
+
+ return Flist (j, maps);
}
DEFUN ("global-set-key", Fglobal_set_key, Sglobal_set_key, 2, 2,
{
register Lisp_Object map;
map = current_buffer->keymap;
- if (NULL (map))
+ if (NILP (map))
{
- map = Fmake_sparse_keymap ();
+ map = Fmake_sparse_keymap (Qnil);
current_buffer->keymap = map;
}
(keys)
Lisp_Object keys;
{
- if (!NULL (current_buffer->keymap))
+ if (!NILP (current_buffer->keymap))
Flocal_set_key (keys, Qnil);
return Qnil;
}
Lisp_Object name, mapvar;
{
Lisp_Object map;
- map = Fmake_sparse_keymap ();
+ map = Fmake_sparse_keymap (Qnil);
Ffset (name, map);
- if (!NULL (mapvar))
+ if (!NILP (mapvar))
Fset (mapvar, map);
else
Fset (name, map);
(keymap)
Lisp_Object keymap;
{
- if (!NULL (keymap))
+ if (!NILP (keymap))
keymap = get_keymap (keymap);
current_buffer->keymap = keymap;
{
return current_global_map;
}
+
+DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_maps, 0, 0, 0,
+ "Return a list of keymaps for the minor modes of the current buffer.")
+ ()
+{
+ Lisp_Object *maps;
+ int nmaps = current_minor_maps (0, &maps);
+
+ return Flist (nmaps, maps);
+}
\f
+/* Help functions for describing and documenting keymaps. */
+
DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
1, 1, 0,
"Find all keymaps accessible via prefix characters from KEYMAP.\n\
{
Lisp_Object maps, tail;
- maps = Fcons (Fcons (build_string (""), get_keymap (startmap)), Qnil);
- tail = maps;
+ maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
+ get_keymap (startmap)),
+ Qnil);
/* For each map in the list maps,
look at any other maps it points to,
This is a breadth-first traversal, where tail is the queue of
nodes, and maps accumulates a list of all nodes visited. */
- while (!NULL (tail))
+ for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr)
{
register Lisp_Object thisseq = Fcar (Fcar (tail));
register Lisp_Object thismap = Fcdr (Fcar (tail));
int is_metized = (XINT (last) >= 0
&& EQ (Faref (thisseq, last), meta_prefix_char));
- /* Skip the 'keymap element of the list. */
- thismap = Fcdr (thismap);
-
- if (CONSP (thismap))
+ for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
{
- register Lisp_Object table = XCONS (thismap)->car;
+ Lisp_Object elt = XCONS (thismap)->car;
- if (XTYPE (table) == Lisp_Vector)
+ QUIT;
+
+ if (XTYPE (elt) == Lisp_Vector)
{
register int i;
register Lisp_Object tem;
register Lisp_Object cmd;
- cmd = get_keyelt (XVECTOR (table)->contents[i]);
- if (NULL (cmd)) continue;
+ cmd = get_keyelt (XVECTOR (elt)->contents[i]);
+ if (NILP (cmd)) continue;
tem = Fkeymapp (cmd);
- if (!NULL (tem))
+ if (!NILP (tem))
{
cmd = get_keymap (cmd);
/* Ignore keymaps that are already added to maps. */
tem = Frassq (cmd, maps);
- if (NULL (tem))
+ if (NILP (tem))
{
/* If the last key in thisseq is meta-prefix-char,
turn it into a meta-ized keystroke. We know
that the event we're about to append is an
- ascii keystroke. */
+ ascii keystroke since we're processing a
+ keymap table. */
if (is_metized)
{
+ int meta_bit = meta_modifier;
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (i | 0200));
+
+ Faset (tem, last, make_number (i | meta_bit));
/* This new sequence is the same length as
thisseq, so stick it in the list right
after this one. */
- XCONS (tail)->cdr =
- Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
+ XCONS (tail)->cdr
+ = Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
}
else
{
}
}
}
-
- /* Once finished with the lookup elements of the dense
- keymap, go on to scan its assoc list. */
- thismap = XCONS (thismap)->cdr;
- }
- }
-
- /* The rest is an alist. Scan all the alist elements. */
- while (CONSP (thismap))
- {
- Lisp_Object elt = XCONS (thismap)->car;
-
- /* Ignore elements that are not conses. */
- if (CONSP (elt))
+ }
+ else if (CONSP (elt))
{
register Lisp_Object cmd = get_keyelt (XCONS (elt)->cdr);
register Lisp_Object tem;
/* Ignore definitions that aren't keymaps themselves. */
tem = Fkeymapp (cmd);
- if (!NULL (tem))
+ if (!NILP (tem))
{
/* Ignore keymaps that have been seen already. */
cmd = get_keymap (cmd);
tem = Frassq (cmd, maps);
- if (NULL (tem))
+ if (NILP (tem))
{
/* let elt be the event defined by this map entry. */
elt = XCONS (elt)->car;
if (is_metized && XTYPE (elt) == Lisp_Int)
{
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (XINT (elt) | 0200));
+ Faset (tem, last,
+ make_number (XINT (elt) | meta_modifier));
/* This new sequence is the same length as
thisseq, so stick it in the list right
}
}
}
-
- thismap = XCONS (thismap)->cdr;
}
-
- tail = Fcdr (tail);
}
return maps;
(keys)
Lisp_Object keys;
{
+ if (XTYPE (keys) == Lisp_String)
+ {
+ Lisp_Object vector;
+ int i;
+ vector = Fmake_vector (Flength (keys), Qnil);
+ for (i = 0; i < XSTRING (keys)->size; i++)
+ {
+ if (XSTRING (keys)->data[i] & 0x80)
+ XFASTINT (XVECTOR (vector)->contents[i])
+ = meta_modifier | (XSTRING (keys)->data[i] & ~0x80);
+ else
+ XFASTINT (XVECTOR (vector)->contents[i])
+ = XSTRING (keys)->data[i];
+ }
+ keys = vector;
+ }
return Fmapconcat (Qsingle_key_description, keys, build_string (" "));
}
register unsigned int c;
register char *p;
{
- if (c >= 0200)
+ if (c & alt_modifier)
+ {
+ *p++ = 'A';
+ *p++ = '-';
+ c -= alt_modifier;
+ }
+ if (c & ctrl_modifier)
+ {
+ *p++ = 'C';
+ *p++ = '-';
+ c -= ctrl_modifier;
+ }
+ if (c & hyper_modifier)
+ {
+ *p++ = 'H';
+ *p++ = '-';
+ c -= hyper_modifier;
+ }
+ if (c & meta_modifier)
{
*p++ = 'M';
*p++ = '-';
- c -= 0200;
+ c -= meta_modifier;
+ }
+ if (c & shift_modifier)
+ {
+ *p++ = 'S';
+ *p++ = '-';
+ c -= shift_modifier;
+ }
+ if (c & super_modifier)
+ {
+ *p++ = 's';
+ *p++ = '-';
+ c -= super_modifier;
}
if (c < 040)
{
*p++ = 'S';
*p++ = 'C';
}
- else if (c == Ctl('I'))
+ else if (c == '\t')
{
*p++ = 'T';
*p++ = 'A';
*p++ = 'P';
*p++ = 'C';
}
- else
+ else if (c < 256)
*p++ = c;
+ else
+ {
+ *p++ = '\\';
+ *p++ = (7 & (c >> 15)) + '0';
+ *p++ = (7 & (c >> 12)) + '0';
+ *p++ = (7 & (c >> 9)) + '0';
+ *p++ = (7 & (c >> 6)) + '0';
+ *p++ = (7 & (c >> 3)) + '0';
+ *p++ = (7 & (c >> 0)) + '0';
+ }
return p;
}
(key)
Lisp_Object key;
{
- register unsigned char c;
- char tem[6];
+ char tem[20];
+
+ key = EVENT_HEAD (key);
switch (XTYPE (key))
{
case Lisp_Int: /* Normal character */
- c = XINT (key) & 0377;
- *push_key_description (c, tem) = 0;
+ *push_key_description (XUINT (key), tem) = 0;
return build_string (tem);
case Lisp_Symbol: /* Function key or event-symbol */
return Fsymbol_name (key);
- case Lisp_Cons: /* Mouse event */
- key = XCONS (key)->car;
- if (XTYPE (key) == Lisp_Symbol)
- return Fsymbol_name (key);
- /* Mouse events should have an identifying symbol as their car;
- fall through when this isn't the case. */
-
default:
error ("KEY must be an integer, cons, or symbol.");
}
return build_string (tem);
}
\f
+/* where-is - finding a command in a set of keymaps. */
+
DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
"Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\
If KEYMAP is nil, search only KEYMAP1.\n\
register Lisp_Object maps;
Lisp_Object found;
- if (NULL (global_keymap))
+ if (NILP (global_keymap))
global_keymap = current_global_map;
- if (!NULL (local_keymap))
+ if (!NILP (local_keymap))
maps = nconc2 (Faccessible_keymaps (get_keymap (local_keymap)),
Faccessible_keymaps (get_keymap (global_keymap)));
else
found = Qnil;
- for (; !NULL (maps); maps = Fcdr (maps))
+ for (; !NILP (maps); maps = Fcdr (maps))
{
- register this = Fcar (Fcar (maps)); /* Key sequence to reach map */
- register map = Fcdr (Fcar (maps)); /* The map that it reaches */
- register dense_alist;
- register int i = 0;
+ /* Key sequence to reach map */
+ register Lisp_Object this = Fcar (Fcar (maps));
+
+ /* The map that it reaches */
+ register Lisp_Object map = Fcdr (Fcar (maps));
+
+ /* 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
Lisp_Object last = make_number (XINT (Flength (this)) - 1);
int last_is_meta = (XINT (last) >= 0
&& EQ (Faref (this, last), meta_prefix_char));
-
- /* Skip the 'keymap element of the list. */
- map = Fcdr (map);
-
- /* If the keymap is sparse, map traverses the alist to the end.
- If the keymap is dense, we set map to the vector and
- dense_alist to the assoc-list portion of the keymap. When we
- are finished dealing with the vector portion, we set map to
- dense_alist, and handle the rest like a sparse keymap. */
- if (XTYPE (XCONS (map)->car) == Lisp_Vector)
- {
- dense_alist = XCONS (map)->cdr;
- map = XCONS (map)->car;
- }
+ QUIT;
- while (1)
+ while (CONSP (map))
{
- register Lisp_Object key, binding, sequence;
+ /* Because the code we want to run on each binding is rather
+ large, we don't want to have two separate loop bodies for
+ sparse keymap bindings and tables; we want to iterate one
+ loop body over both keymap and vector bindings.
+
+ 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 = XCONS (map)->car;
+ Lisp_Object key, binding, sequence;
+
QUIT;
- if (XTYPE (map) == Lisp_Vector)
+
+ /* Set key and binding to the current key and binding, and
+ advance map and i to the next binding. */
+ if (XTYPE (elt) == Lisp_Vector)
{
/* In a vector, look at each element. */
- binding = XVECTOR (map)->contents[i];
+ binding = XVECTOR (elt)->contents[i];
XFASTINT (key) = i;
i++;
- /* If we've just finished scanning a vector, switch map to
- the assoc-list at the end of the vector. */
+ /* 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 >= DENSE_TABLE_SIZE)
- map = dense_alist;
- }
- else if (CONSP (map))
- {
- /* In an alist, ignore elements that aren't conses. */
- if (! CONSP (XCONS (map)->car))
{
- /* Ignore other elements. */
- map = Fcdr (map);
- continue;
+ map = XCONS (map)->cdr;
+ i = 0;
}
- binding = Fcdr (Fcar (map));
+ }
+ else if (CONSP (elt))
+ {
key = Fcar (Fcar (map));
- map = Fcdr (map);
+ binding = Fcdr (Fcar (map));
+
+ map = XCONS (map)->cdr;
}
else
- break;
+ /* We want to ignore keymap elements that are neither
+ vectors nor conses. */
+ {
+ map = XCONS (map)->cdr;
+ continue;
+ }
/* Search through indirections unless that's not wanted. */
- if (NULL (noindirect))
+ if (NILP (noindirect))
binding = get_keyelt (binding);
/* End this iteration if this element does not match
{
Lisp_Object tem;
tem = Fequal (binding, definition);
- if (NULL (tem))
+ if (NILP (tem))
continue;
}
else
if (XTYPE (key) == Lisp_Int && last_is_meta)
{
sequence = Fcopy_sequence (this);
- Faset (sequence, last, make_number (XINT (key) | 0200));
+ Faset (sequence, last, make_number (XINT (key) | meta_modifier));
}
else
sequence = append_key (this, key);
Either nil or number as value from Flookup_key
means undefined. */
- if (!NULL (local_keymap))
+ if (!NILP (local_keymap))
{
- binding = Flookup_key (local_keymap, sequence);
- if (!NULL (binding) && XTYPE (binding) != Lisp_Int)
+ binding = Flookup_key (local_keymap, sequence, Qnil);
+ if (!NILP (binding) && XTYPE (binding) != Lisp_Int)
{
if (XTYPE (definition) == Lisp_Cons)
{
Lisp_Object tem;
tem = Fequal (binding, definition);
- if (NULL (tem))
+ if (NILP (tem))
continue;
}
else
/* It is a true unshadowed match. Record it. */
- if (!NULL (firstonly))
+ if (!NILP (firstonly))
return sequence;
found = Fcons (sequence, found);
}
return Qnil;
}
\f
+/* describe-bindings - summarizing all the bindings in a set of keymaps. */
+
DEFUN ("describe-bindings", Fdescribe_bindings, Sdescribe_bindings, 0, 0, "",
"Show a list of all defined keys, and their definitions.\n\
The list is put in a buffer, which is displayed.")
{
register Lisp_Object start1, start2;
- char *heading
- = "key binding\n--- -------\n";
+ char *key_heading
+ = "\
+key binding\n\
+--- -------\n";
+ char *alternate_heading
+ = "\
+Alternate Characters (use anywhere the nominal character is listed):\n\
+nominal alternate\n\
+------- ---------\n";
Fset_buffer (Vstandard_output);
+ /* Report on alternates for keys. */
+ if (XTYPE (Vkeyboard_translate_table) == Lisp_String)
+ {
+ int c;
+ unsigned char *translate = XSTRING (Vkeyboard_translate_table)->data;
+ int translate_len = XSTRING (Vkeyboard_translate_table)->size;
+
+ for (c = 0; c < translate_len; c++)
+ if (translate[c] != c)
+ {
+ char buf[20];
+ char *bufend;
+
+ if (alternate_heading)
+ {
+ insert_string (alternate_heading);
+ alternate_heading = 0;
+ }
+
+ bufend = push_key_description (translate[c], buf);
+ insert (buf, bufend - buf);
+ Findent_to (make_number (16), make_number (1));
+ bufend = push_key_description (c, buf);
+ insert (buf, bufend - buf);
+
+ insert ("\n", 1);
+ }
+
+ insert ("\n", 1);
+ }
+
+ {
+ int i, nmaps;
+ Lisp_Object *modes, *maps;
+
+ /* Temporarily switch to descbuf, so that we can get that buffer's
+ minor modes correctly. */
+ Fset_buffer (descbuf);
+ nmaps = current_minor_maps (&modes, &maps);
+ Fset_buffer (Vstandard_output);
+
+ for (i = 0; i < nmaps; i++)
+ {
+ if (XTYPE (modes[i]) == Lisp_Symbol)
+ {
+ insert_char ('`');
+ insert_string (XSYMBOL (modes[i])->name->data);
+ insert_char ('\'');
+ }
+ else
+ insert_string ("Strangely Named");
+ insert_string (" Minor Mode Bindings:\n");
+ insert_string (key_heading);
+ describe_map_tree (maps[i], 0, Qnil);
+ insert_char ('\n');
+ }
+ }
+
start1 = XBUFFER (descbuf)->keymap;
- if (!NULL (start1))
+ if (!NILP (start1))
{
insert_string ("Local Bindings:\n");
- insert_string (heading);
- describe_map_tree (start1, 0, Qnil, Qnil);
+ insert_string (key_heading);
+ describe_map_tree (start1, 0, Qnil);
insert_string ("\n");
}
insert_string ("Global Bindings:\n");
- insert_string (heading);
+ if (NILP (start1))
+ insert_string (key_heading);
- describe_map_tree (current_global_map, 0, XBUFFER (descbuf)->keymap, Qnil);
+ describe_map_tree (current_global_map, 0, XBUFFER (descbuf)->keymap);
Fset_buffer (descbuf);
return Qnil;
maps = Faccessible_keymaps (startmap);
GCPRO1 (maps);
- for (; !NULL (maps); maps = Fcdr (maps))
+ for (; !NILP (maps); maps = Fcdr (maps))
{
elt = Fcar (maps);
sh = Fcar (elt);
/* If there is no shadow keymap given, don't shadow. */
- if (NULL (shadow))
+ if (NILP (shadow))
sh = Qnil;
/* If the sequence by which we reach this keymap is zero-length,
what we should use. */
else
{
- sh = Flookup_key (shadow, Fcar (elt));
+ sh = Flookup_key (shadow, Fcar (elt), Qt);
if (XTYPE (sh) == Lisp_Int)
sh = Qnil;
}
show through), describe the map. Otherwise, sh is a command
that completely shadows the current map, and we shouldn't
bother. */
- if (NULL (sh) || !NULL (Fkeymapp (sh)))
+ if (NILP (sh) || !NILP (Fkeymapp (sh)))
describe_map (Fcdr (elt), Fcar (elt), partial, sh);
}
else
{
tem1 = Fkeymapp (definition);
- if (!NULL (tem1))
+ if (!NILP (tem1))
insert_string ("Prefix Command\n");
else
insert_string ("??\n");
{
register Lisp_Object keysdesc;
- if (!NULL (keys) && Flength (keys) > 0)
- keysdesc = concat2 (Fkey_description (keys),
- build_string (" "));
- else
- keysdesc = Qnil;
-
- /* Skip the 'keymap element of the list. */
- map = Fcdr (map);
-
- /* If this is a dense keymap, take care of the table. */
- if (CONSP (map)
- && XTYPE (XCONS (map)->car) == Lisp_Vector)
+ if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
{
- describe_vector (XCONS (map)->car, keysdesc, describe_command,
- partial, shadow);
- map = XCONS (map)->cdr;
+ Lisp_Object tem;
+ /* Call Fkey_description first, to avoid GC bug for the other string. */
+ tem = Fkey_description (keys);
+ keysdesc = concat2 (tem, build_string (" "));
}
+ else
+ keysdesc = Qnil;
- /* Now map is an alist. */
- describe_alist (map, keysdesc, describe_command, partial, shadow);
+ describe_map_2 (map, keysdesc, describe_command, partial, shadow);
}
-/* Insert a description of ALIST into the current buffer.
- Note that ALIST is just a plain association list, not a keymap. */
+/* Insert a description of KEYMAP into the current buffer. */
static void
-describe_alist (alist, elt_prefix, elt_describer, partial, shadow)
- register Lisp_Object alist;
+describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
+ register Lisp_Object keymap;
Lisp_Object elt_prefix;
int (*elt_describer) ();
int partial;
suppress = intern ("suppress-keymap");
/* This vector gets used to present single keys to Flookup_key. Since
- that is done once per alist element, we don't want to cons up a
+ that is done once per keymap element, we don't want to cons up a
fresh vector every time. */
kludge = Fmake_vector (make_number (1), Qnil);
GCPRO3 (elt_prefix, tem2, kludge);
- for (; CONSP (alist); alist = Fcdr (alist))
+ for (; CONSP (keymap); keymap = Fcdr (keymap))
{
QUIT;
- tem1 = Fcar_safe (Fcar (alist));
- tem2 = get_keyelt (Fcdr_safe (Fcar (alist)));
- /* Don't show undefined commands or suppressed commands. */
- if (NULL (tem2)) continue;
- if (XTYPE (tem2) == Lisp_Symbol && partial)
+ if (XTYPE (XCONS (keymap)->car) == Lisp_Vector)
+ describe_vector (XCONS (keymap)->car,
+ elt_prefix, elt_describer, partial, shadow);
+ else
{
- this = Fget (tem2, suppress);
- if (!NULL (this))
- continue;
- }
+ tem1 = Fcar_safe (Fcar (keymap));
+ tem2 = get_keyelt (Fcdr_safe (Fcar (keymap)));
- /* Don't show a command that isn't really visible
- because a local definition of the same key shadows it. */
+ /* Don't show undefined commands or suppressed commands. */
+ if (NILP (tem2)) continue;
+ if (XTYPE (tem2) == Lisp_Symbol && partial)
+ {
+ this = Fget (tem2, suppress);
+ if (!NILP (this))
+ continue;
+ }
- if (!NULL (shadow))
- {
- Lisp_Object tem;
+ /* Don't show a command that isn't really visible
+ because a local definition of the same key shadows it. */
- XVECTOR (kludge)->contents[0] = tem1;
- tem = Flookup_key (shadow, kludge);
- if (!NULL (tem)) continue;
- }
+ if (!NILP (shadow))
+ {
+ Lisp_Object tem;
- if (first)
- {
- insert ("\n", 1);
- first = 0;
- }
+ XVECTOR (kludge)->contents[0] = tem1;
+ tem = Flookup_key (shadow, kludge, Qt);
+ if (!NILP (tem)) continue;
+ }
- if (!NULL (elt_prefix))
- insert1 (elt_prefix);
+ if (first)
+ {
+ insert ("\n", 1);
+ first = 0;
+ }
- /* THIS gets the string to describe the character TEM1. */
- this = Fsingle_key_description (tem1);
- insert1 (this);
+ if (!NILP (elt_prefix))
+ insert1 (elt_prefix);
- /* Print a description of the definition of this character.
- elt_describer will take care of spacing out far enough
- for alignment purposes. */
- (*elt_describer) (tem2);
+ /* THIS gets the string to describe the character TEM1. */
+ this = Fsingle_key_description (tem1);
+ insert1 (this);
+
+ /* Print a description of the definition of this character.
+ elt_describer will take care of spacing out far enough
+ for alignment purposes. */
+ (*elt_describer) (tem2);
+ }
}
UNGCPRO;
Lisp_Object vector;
{
CHECK_VECTOR (vector, 0);
- describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil, Qnil);
+ describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil);
}
describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
QUIT;
tem1 = get_keyelt (XVECTOR (vector)->contents[i]);
- if (NULL (tem1)) continue;
+ if (NILP (tem1)) continue;
/* Don't mention suppressed commands. */
if (XTYPE (tem1) == Lisp_Symbol && partial)
{
this = Fget (tem1, suppress);
- if (!NULL (this))
+ if (!NILP (this))
continue;
}
/* If this command in this map is shadowed by some other map,
ignore it. */
- if (!NULL (shadow))
+ if (!NILP (shadow))
{
Lisp_Object tem;
XVECTOR (kludge)->contents[0] = make_number (i);
- tem = Flookup_key (shadow, kludge);
+ tem = Flookup_key (shadow, kludge, Qt);
- if (!NULL (tem)) continue;
+ if (!NILP (tem)) continue;
}
if (first)
}
/* Output the prefix that applies to every entry in this map. */
- if (!NULL (elt_prefix))
+ if (!NILP (elt_prefix))
insert1 (elt_prefix);
/* Get the string to describe the character I, and print it. */
if (i != XINT (dummy))
{
insert (" .. ", 4);
- if (!NULL (elt_prefix))
+ if (!NILP (elt_prefix))
insert1 (elt_prefix);
XFASTINT (dummy) = i;
UNGCPRO;
}
\f
-/* Apropos */
+/* Apropos - finding all symbols whose names match a regexp. */
Lisp_Object apropos_predicate;
Lisp_Object apropos_accumulate;
register Lisp_Object tem;
tem = Fstring_match (string, Fsymbol_name (symbol), Qnil);
- if (!NULL (tem) && !NULL (apropos_predicate))
+ if (!NILP (tem) && !NILP (apropos_predicate))
tem = call1 (apropos_predicate, symbol);
- if (!NULL (tem))
+ if (!NILP (tem))
apropos_accumulate = Fcons (symbol, apropos_accumulate);
}
Each one is the value of a Lisp variable, and is also
pointed to by a C variable */
- global_map = Fmake_keymap ();
+ global_map = Fmake_keymap (Qnil);
Fset (intern ("global-map"), global_map);
- meta_map = Fmake_keymap ();
+ meta_map = Fmake_keymap (Qnil);
Fset (intern ("esc-map"), meta_map);
Ffset (intern ("ESC-prefix"), meta_map);
- control_x_map = Fmake_keymap ();
+ control_x_map = Fmake_keymap (Qnil);
Fset (intern ("ctl-x-map"), control_x_map);
Ffset (intern ("Control-X-prefix"), control_x_map);
DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map,
"Default keymap to use when reading from the minibuffer.");
- Vminibuffer_local_map = Fmake_sparse_keymap ();
+ Vminibuffer_local_map = Fmake_sparse_keymap (Qnil);
DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map,
"Local keymap for the minibuffer when spaces are not allowed.");
- Vminibuffer_local_ns_map = Fmake_sparse_keymap ();
+ Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil);
DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map,
"Local keymap for minibuffer input with completion.");
- Vminibuffer_local_completion_map = Fmake_sparse_keymap ();
+ Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil);
DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map,
"Local keymap for minibuffer input with completion, for exact match.");
- Vminibuffer_local_must_match_map = Fmake_sparse_keymap ();
+ Vminibuffer_local_must_match_map = Fmake_sparse_keymap (Qnil);
current_global_map = global_map;
+ DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist,
+ "Alist of keymaps to use for minor modes.\n\
+Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
+key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
+If two active keymaps bind the same key, the keymap appearing earlier\n\
+in the list takes precedence.");
+ Vminor_mode_map_alist = Qnil;
+
+ DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
+ "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
+This allows Emacs to recognize function keys sent from ASCII\n\
+terminals at any point in a key sequence.\n\
+\n\
+The read-key-sequence function replaces subsequences bound by\n\
+function-key-map with their bindings. When the current local and global\n\
+keymaps have no binding for the current key sequence but\n\
+function-key-map binds a suffix of the sequence to a vector,\n\
+read-key-sequence replaces the matching suffix with its binding, and\n\
+continues with the new sequence.\n\
+\n\
+For example, suppose function-key-map binds `ESC O P' to [pf1].\n\
+Typing `ESC O P' to read-key-sequence would return [pf1]. Typing\n\
+`C-x ESC O P' would return [?\C-x pf1]. If [pf1] were a prefix\n\
+key, typing `ESC O P x' would return [pf1 x].");
+ Vfunction_key_map = Fmake_sparse_keymap (Qnil);
+
Qsingle_key_description = intern ("single-key-description");
staticpro (&Qsingle_key_description);
defsubr (&Skey_binding);
defsubr (&Slocal_key_binding);
defsubr (&Sglobal_key_binding);
+ defsubr (&Sminor_mode_key_binding);
defsubr (&Sglobal_set_key);
defsubr (&Slocal_set_key);
defsubr (&Sdefine_key);
defsubr (&Suse_local_map);
defsubr (&Scurrent_local_map);
defsubr (&Scurrent_global_map);
+ defsubr (&Scurrent_minor_mode_maps);
defsubr (&Saccessible_keymaps);
defsubr (&Skey_description);
defsubr (&Sdescribe_vector);
HCoop / bpt / emacs.git / blobdiff