Mercurial > emacs
annotate src/keymap.c @ 2727:b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
returning a non-ascii key sequence unless FIRSTONLY is the symbol
`non-ascii'.
author | Jim Blandy <jimb@redhat.com> |
---|---|
date | Mon, 10 May 1993 00:17:31 +0000 |
parents | 90485f37bfc3 |
children | 93eda5bbc4df |
rev | line source |
---|---|
250 | 1 /* Manipulation of keymaps |
647 | 2 Copyright (C) 1985, 1986, 1987, 1988, 1992 Free Software Foundation, Inc. |
250 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
6 GNU Emacs is free software; you can redistribute it and/or modify | |
7 it under the terms of the GNU General Public License as published by | |
647 | 8 the Free Software Foundation; either version 2, or (at your option) |
250 | 9 any later version. |
10 | |
11 GNU Emacs is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 | |
21 #include "config.h" | |
22 #include <stdio.h> | |
23 #undef NULL | |
24 #include "lisp.h" | |
25 #include "commands.h" | |
26 #include "buffer.h" | |
517 | 27 #include "keyboard.h" |
2059 | 28 #include "termhooks.h" |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2358
diff
changeset
|
29 #include "blockinput.h" |
250 | 30 |
31 #define min(a, b) ((a) < (b) ? (a) : (b)) | |
32 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
33 /* The number of elements in keymap vectors. */ |
250 | 34 #define DENSE_TABLE_SIZE (0200) |
35 | |
36 /* Actually allocate storage for these variables */ | |
37 | |
38 Lisp_Object current_global_map; /* Current global keymap */ | |
39 | |
40 Lisp_Object global_map; /* default global key bindings */ | |
41 | |
42 Lisp_Object meta_map; /* The keymap used for globally bound | |
43 ESC-prefixed default commands */ | |
44 | |
45 Lisp_Object control_x_map; /* The keymap used for globally bound | |
46 C-x-prefixed default commands */ | |
47 | |
48 /* was MinibufLocalMap */ | |
49 Lisp_Object Vminibuffer_local_map; | |
50 /* The keymap used by the minibuf for local | |
51 bindings when spaces are allowed in the | |
52 minibuf */ | |
53 | |
54 /* was MinibufLocalNSMap */ | |
55 Lisp_Object Vminibuffer_local_ns_map; | |
56 /* The keymap used by the minibuf for local | |
57 bindings when spaces are not encouraged | |
58 in the minibuf */ | |
59 | |
60 /* keymap used for minibuffers when doing completion */ | |
61 /* was MinibufLocalCompletionMap */ | |
62 Lisp_Object Vminibuffer_local_completion_map; | |
63 | |
64 /* keymap used for minibuffers when doing completion and require a match */ | |
65 /* was MinibufLocalMustMatchMap */ | |
66 Lisp_Object Vminibuffer_local_must_match_map; | |
67 | |
465 | 68 /* Alist of minor mode variables and keymaps. */ |
69 Lisp_Object Vminor_mode_map_alist; | |
70 | |
517 | 71 /* Keymap mapping ASCII function key sequences onto their preferred forms. |
72 Initialized by the terminal-specific lisp files. See DEFVAR for more | |
73 documentation. */ | |
74 Lisp_Object Vfunction_key_map; | |
75 | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
76 Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii; |
250 | 77 |
78 /* A char over 0200 in a key sequence | |
79 is equivalent to prefixing with this character. */ | |
80 | |
81 extern Lisp_Object meta_prefix_char; | |
82 | |
83 void describe_map_tree (); | |
84 static Lisp_Object describe_buffer_bindings (); | |
85 static void describe_command (); | |
86 static void describe_map (); | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
87 static void describe_map_2 (); |
250 | 88 |
465 | 89 /* Keymap object support - constructors and predicates. */ |
90 | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
91 DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0, |
250 | 92 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\ |
93 VECTOR is a 128-element vector which holds the bindings for the ASCII\n\ | |
94 characters. ALIST is an assoc-list which holds bindings for function keys,\n\ | |
95 mouse events, and any other things that appear in the input stream.\n\ | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
96 All entries in it are initially nil, meaning \"command undefined\".\n\n\ |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
97 The optional arg STRING supplies a menu name for the keymap\n\ |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
98 in case you use it as a menu with `x-popup-menu'.") |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
99 (string) |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
100 Lisp_Object string; |
250 | 101 { |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
102 Lisp_Object tail; |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
103 if (!NILP (string)) |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
104 tail = Fcons (string, Qnil); |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
105 else |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
106 tail = Qnil; |
250 | 107 return Fcons (Qkeymap, |
108 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE), Qnil), | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
109 tail)); |
250 | 110 } |
111 | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
112 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0, |
250 | 113 "Construct and return a new sparse-keymap list.\n\ |
114 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\ | |
115 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\ | |
116 which binds the function key or mouse event SYMBOL to DEFINITION.\n\ | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
117 Initially the alist is nil.\n\n\ |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
118 The optional arg STRING supplies a menu name for the keymap\n\ |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
119 in case you use it as a menu with `x-popup-menu'.") |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
120 (string) |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
121 Lisp_Object string; |
250 | 122 { |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
123 if (!NILP (string)) |
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
124 return Fcons (Qkeymap, Fcons (string, Qnil)); |
250 | 125 return Fcons (Qkeymap, Qnil); |
126 } | |
127 | |
128 /* This function is used for installing the standard key bindings | |
129 at initialization time. | |
130 | |
131 For example: | |
132 | |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
133 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */ |
250 | 134 |
135 void | |
136 initial_define_key (keymap, key, defname) | |
137 Lisp_Object keymap; | |
138 int key; | |
139 char *defname; | |
140 { | |
141 store_in_keymap (keymap, make_number (key), intern (defname)); | |
142 } | |
143 | |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
144 void |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
145 initial_define_lispy_key (keymap, keyname, defname) |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
146 Lisp_Object keymap; |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
147 char *keyname; |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
148 char *defname; |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
149 { |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
150 store_in_keymap (keymap, intern (keyname), intern (defname)); |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
151 } |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
152 |
250 | 153 /* Define character fromchar in map frommap as an alias for character |
154 tochar in map tomap. Subsequent redefinitions of the latter WILL | |
155 affect the former. */ | |
156 | |
157 #if 0 | |
158 void | |
159 synkey (frommap, fromchar, tomap, tochar) | |
160 struct Lisp_Vector *frommap, *tomap; | |
161 int fromchar, tochar; | |
162 { | |
163 Lisp_Object v, c; | |
164 XSET (v, Lisp_Vector, tomap); | |
165 XFASTINT (c) = tochar; | |
166 frommap->contents[fromchar] = Fcons (v, c); | |
167 } | |
168 #endif /* 0 */ | |
169 | |
170 DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0, | |
171 "Return t if ARG is a keymap.\n\ | |
362 | 172 \n\ |
2358
e99cada8fb8f
* keymap.c (Fkeymapp): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
2343
diff
changeset
|
173 A keymap is a list (keymap . ALIST), a list (keymap VECTOR . ALIST),\n\ |
362 | 174 or a symbol whose function definition is a keymap is itself a keymap.\n\ |
175 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\ | |
176 VECTOR is a 128-element vector of bindings for ASCII characters.") | |
250 | 177 (object) |
178 Lisp_Object object; | |
179 { | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
180 return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt); |
250 | 181 } |
182 | |
183 /* Check that OBJECT is a keymap (after dereferencing through any | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
184 symbols). If it is, return it. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
185 |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
186 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
187 is an autoload form, do the autoload and try again. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
188 |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
189 ERROR controls how we respond if OBJECT isn't a keymap. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
190 If ERROR is non-zero, signal an error; otherwise, just return Qnil. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
191 |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
192 Note that most of the time, we don't want to pursue autoloads. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
193 Functions like Faccessible_keymaps which scan entire keymap trees |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
194 shouldn't load every autoloaded keymap. I'm not sure about this, |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
195 but it seems to me that only read_key_sequence, Flookup_key, and |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
196 Fdefine_key should cause keymaps to be autoloaded. */ |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
197 |
250 | 198 Lisp_Object |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
199 get_keymap_1 (object, error, autoload) |
250 | 200 Lisp_Object object; |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
201 int error, autoload; |
250 | 202 { |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
203 Lisp_Object tem; |
250 | 204 |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
205 autoload_retry: |
647 | 206 tem = indirect_function (object); |
250 | 207 if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap)) |
208 return tem; | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
209 |
1566
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
210 /* Should we do an autoload? Autoload forms for keymaps have |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
211 Qkeymap as their fifth element. */ |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
212 if (autoload |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
213 && XTYPE (object) == Lisp_Symbol |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
214 && CONSP (tem) |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
215 && EQ (XCONS (tem)->car, Qautoload)) |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
216 { |
1566
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
217 Lisp_Object tail; |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
218 |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
219 tail = Fnth (make_number (4), tem); |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
220 if (EQ (tail, Qkeymap)) |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
221 { |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
222 struct gcpro gcpro1, gcpro2; |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
223 |
1566
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
224 GCPRO2 (tem, object) |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
225 do_autoload (tem, object); |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
226 UNGCPRO; |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
227 |
1566
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
228 goto autoload_retry; |
892c9f61217a
* keymap.c (get_keymap_1): Don't try to autoload OBJECT's function
Jim Blandy <jimb@redhat.com>
parents:
1517
diff
changeset
|
229 } |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
230 } |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
231 |
250 | 232 if (error) |
233 wrong_type_argument (Qkeymapp, object); | |
465 | 234 else |
235 return Qnil; | |
250 | 236 } |
237 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
238 |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
239 /* Follow any symbol chaining, and return the keymap denoted by OBJECT. |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
240 If OBJECT doesn't denote a keymap at all, signal an error. */ |
250 | 241 Lisp_Object |
242 get_keymap (object) | |
243 Lisp_Object object; | |
244 { | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
245 return get_keymap_1 (object, 0, 0); |
250 | 246 } |
247 | |
248 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
249 /* Look up IDX in MAP. IDX may be any sort of event. |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
250 Note that this does only one level of lookup; IDX must be a single |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
251 event, not a sequence. |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
252 |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
253 If T_OK is non-zero, bindings for Qt are treated as default |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
254 bindings; any key left unmentioned by other tables and bindings is |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
255 given the binding of Qt. |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
256 |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
257 If T_OK is zero, bindings for Qt are not treated specially. */ |
250 | 258 |
259 Lisp_Object | |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
260 access_keymap (map, idx, t_ok) |
250 | 261 Lisp_Object map; |
262 Lisp_Object idx; | |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
263 int t_ok; |
250 | 264 { |
265 /* If idx is a list (some sort of mouse click, perhaps?), | |
266 the index we want to use is the car of the list, which | |
267 ought to be a symbol. */ | |
1315
884c3d7e7172
* keymap.c (access_keymap, store_in_keymap,
Jim Blandy <jimb@redhat.com>
parents:
1264
diff
changeset
|
268 idx = EVENT_HEAD (idx); |
250 | 269 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
270 /* If idx is a symbol, it might have modifiers, which need to |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
271 be put in the canonical order. */ |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
272 if (XTYPE (idx) == Lisp_Symbol) |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
273 idx = reorder_modifiers (idx); |
250 | 274 |
275 { | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
276 Lisp_Object tail; |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
277 Lisp_Object t_binding = Qnil; |
250 | 278 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
279 for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
280 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
281 Lisp_Object binding = XCONS (tail)->car; |
250 | 282 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
283 switch (XTYPE (binding)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
284 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
285 case Lisp_Cons: |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
286 if (EQ (XCONS (binding)->car, idx)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
287 return XCONS (binding)->cdr; |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
288 if (t_ok && EQ (XCONS (binding)->car, Qt)) |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
289 t_binding = XCONS (binding)->cdr; |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
290 break; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
291 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
292 case Lisp_Vector: |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
293 if (XVECTOR (binding)->size == DENSE_TABLE_SIZE |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
294 && XTYPE (idx) == Lisp_Int |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
295 && XINT (idx) >= 0 |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
296 && XINT (idx) < DENSE_TABLE_SIZE) |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
297 return XVECTOR (binding)->contents[XINT (idx)]; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
298 break; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
299 } |
1264
6ba9d5aaace6
* keymap.c (access_keymap): Don't forget to QUIT while scanning
Jim Blandy <jimb@redhat.com>
parents:
1236
diff
changeset
|
300 |
6ba9d5aaace6
* keymap.c (access_keymap): Don't forget to QUIT while scanning
Jim Blandy <jimb@redhat.com>
parents:
1236
diff
changeset
|
301 QUIT; |
250 | 302 } |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
303 |
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
304 return t_binding; |
1236
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
305 } |
250 | 306 } |
307 | |
308 /* Given OBJECT which was found in a slot in a keymap, | |
309 trace indirect definitions to get the actual definition of that slot. | |
310 An indirect definition is a list of the form | |
311 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one | |
312 and INDEX is the object to look up in KEYMAP to yield the definition. | |
313 | |
314 Also if OBJECT has a menu string as the first element, | |
1160
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
315 remove that. Also remove a menu help string as second element. */ |
250 | 316 |
317 Lisp_Object | |
318 get_keyelt (object) | |
319 register Lisp_Object object; | |
320 { | |
321 while (1) | |
322 { | |
323 register Lisp_Object map, tem; | |
324 | |
1236
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
325 /* If the contents are (KEYMAP . ELEMENT), go indirect. */ |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
326 map = get_keymap_1 (Fcar_safe (object), 0, 0); |
250 | 327 tem = Fkeymapp (map); |
485 | 328 if (!NILP (tem)) |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
329 object = access_keymap (map, Fcdr (object), 0); |
250 | 330 |
331 /* If the keymap contents looks like (STRING . DEFN), | |
332 use DEFN. | |
333 Keymap alist elements like (CHAR MENUSTRING . DEFN) | |
334 will be used by HierarKey menus. */ | |
335 else if (XTYPE (object) == Lisp_Cons | |
336 && XTYPE (XCONS (object)->car) == Lisp_String) | |
1160
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
337 { |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
338 object = XCONS (object)->cdr; |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
339 /* Also remove a menu help string, if any, |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
340 following the menu item name. */ |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
341 if (XTYPE (object) == Lisp_Cons |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
342 && XTYPE (XCONS (object)->car) == Lisp_String) |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
343 object = XCONS (object)->cdr; |
f7b55bfe1c05
(get_keyelt): Skip menu help string after menu item name.
Richard M. Stallman <rms@gnu.org>
parents:
1120
diff
changeset
|
344 } |
250 | 345 |
346 else | |
347 /* Anything else is really the value. */ | |
348 return object; | |
349 } | |
350 } | |
351 | |
352 Lisp_Object | |
353 store_in_keymap (keymap, idx, def) | |
354 Lisp_Object keymap; | |
355 register Lisp_Object idx; | |
356 register Lisp_Object def; | |
357 { | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
358 if (XTYPE (keymap) != Lisp_Cons |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
359 || ! EQ (XCONS (keymap)->car, Qkeymap)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
360 error ("attempt to define a key in a non-keymap"); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
361 |
250 | 362 /* If idx is a list (some sort of mouse click, perhaps?), |
363 the index we want to use is the car of the list, which | |
364 ought to be a symbol. */ | |
1315
884c3d7e7172
* keymap.c (access_keymap, store_in_keymap,
Jim Blandy <jimb@redhat.com>
parents:
1264
diff
changeset
|
365 idx = EVENT_HEAD (idx); |
250 | 366 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
367 /* If idx is a symbol, it might have modifiers, which need to |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
368 be put in the canonical order. */ |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
369 if (XTYPE (idx) == Lisp_Symbol) |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
370 idx = reorder_modifiers (idx); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
371 |
250 | 372 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
373 /* Scan the keymap for a binding of idx. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
374 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
375 Lisp_Object tail; |
250 | 376 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
377 /* The cons after which we should insert new bindings. If the |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
378 keymap has a table element, we record its position here, so new |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
379 bindings will go after it; this way, the table will stay |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
380 towards the front of the alist and character lookups in dense |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
381 keymaps will remain fast. Otherwise, this just points at the |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
382 front of the keymap. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
383 Lisp_Object insertion_point = keymap; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
384 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
385 for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr) |
250 | 386 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
387 Lisp_Object elt = XCONS (tail)->car; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
388 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
389 switch (XTYPE (elt)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
390 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
391 case Lisp_Vector: |
1441
929409595312
* keymap.c (store_in_keymap): Don't forget to QUIT in the
Jim Blandy <jimb@redhat.com>
parents:
1388
diff
changeset
|
392 if (XVECTOR (elt)->size != DENSE_TABLE_SIZE) |
929409595312
* keymap.c (store_in_keymap): Don't forget to QUIT in the
Jim Blandy <jimb@redhat.com>
parents:
1388
diff
changeset
|
393 break; |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
394 if (XTYPE (idx) == Lisp_Int |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
395 && XINT (idx) >= 0 && XINT (idx) < DENSE_TABLE_SIZE) |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
396 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
397 XVECTOR (elt)->contents[XFASTINT (idx)] = def; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
398 return def; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
399 } |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
400 insertion_point = tail; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
401 break; |
250 | 402 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
403 case Lisp_Cons: |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
404 if (EQ (idx, XCONS (elt)->car)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
405 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
406 XCONS (elt)->cdr = def; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
407 return def; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
408 } |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
409 break; |
250 | 410 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
411 case Lisp_Symbol: |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
412 /* If we find a 'keymap' symbol in the spine of KEYMAP, |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
413 then we must have found the start of a second keymap |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
414 being used as the tail of KEYMAP, and a binding for IDX |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
415 should be inserted before it. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
416 if (EQ (elt, Qkeymap)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
417 goto keymap_end; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
418 break; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
419 } |
1441
929409595312
* keymap.c (store_in_keymap): Don't forget to QUIT in the
Jim Blandy <jimb@redhat.com>
parents:
1388
diff
changeset
|
420 |
929409595312
* keymap.c (store_in_keymap): Don't forget to QUIT in the
Jim Blandy <jimb@redhat.com>
parents:
1388
diff
changeset
|
421 QUIT; |
250 | 422 } |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
423 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
424 keymap_end: |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
425 /* We have scanned the entire keymap, and not found a binding for |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
426 IDX. Let's add one. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
427 XCONS (insertion_point)->cdr = |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
428 Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr); |
250 | 429 } |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
430 |
250 | 431 return def; |
432 } | |
433 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
434 |
250 | 435 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0, |
436 "Return a copy of the keymap KEYMAP.\n\ | |
437 The copy starts out with the same definitions of KEYMAP,\n\ | |
438 but changing either the copy or KEYMAP does not affect the other.\n\ | |
362 | 439 Any key definitions that are subkeymaps are recursively copied.\n\ |
440 However, a key definition which is a symbol whose definition is a keymap\n\ | |
441 is not copied.") | |
250 | 442 (keymap) |
443 Lisp_Object keymap; | |
444 { | |
445 register Lisp_Object copy, tail; | |
446 | |
447 copy = Fcopy_alist (get_keymap (keymap)); | |
448 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
449 for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr) |
250 | 450 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
451 Lisp_Object elt = XCONS (tail)->car; |
250 | 452 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
453 if (XTYPE (elt) == Lisp_Vector |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
454 && XVECTOR (elt)->size == DENSE_TABLE_SIZE) |
250 | 455 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
456 int i; |
250 | 457 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
458 elt = Fcopy_sequence (elt); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
459 XCONS (tail)->car = elt; |
250 | 460 |
461 for (i = 0; i < DENSE_TABLE_SIZE; i++) | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
462 if (XTYPE (XVECTOR (elt)->contents[i]) != Lisp_Symbol |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
463 && Fkeymapp (XVECTOR (elt)->contents[i])) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
464 XVECTOR (elt)->contents[i] = |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
465 Fcopy_keymap (XVECTOR (elt)->contents[i]); |
250 | 466 } |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
467 else if (CONSP (elt) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
468 && XTYPE (XCONS (elt)->cdr) != Lisp_Symbol |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
469 && ! NILP (Fkeymapp (XCONS (elt)->cdr))) |
250 | 470 XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr); |
471 } | |
472 | |
473 return copy; | |
474 } | |
475 | |
465 | 476 /* Simple Keymap mutators and accessors. */ |
477 | |
250 | 478 DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0, |
479 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\ | |
480 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\ | |
481 meaning a sequence of keystrokes and events.\n\ | |
482 DEF is anything that can be a key's definition:\n\ | |
483 nil (means key is undefined in this keymap),\n\ | |
484 a command (a Lisp function suitable for interactive calling)\n\ | |
485 a string (treated as a keyboard macro),\n\ | |
486 a keymap (to define a prefix key),\n\ | |
487 a symbol. When the key is looked up, the symbol will stand for its\n\ | |
488 function definition, which should at that time be one of the above,\n\ | |
489 or another symbol whose function definition is used, etc.\n\ | |
490 a cons (STRING . DEFN), meaning that DEFN is the definition\n\ | |
491 (DEFN should be a valid definition in its own right),\n\ | |
368 | 492 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\ |
493 \n\ | |
494 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\ | |
495 the front of KEYMAP.") | |
250 | 496 (keymap, key, def) |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
497 Lisp_Object keymap; |
250 | 498 Lisp_Object key; |
499 Lisp_Object def; | |
500 { | |
501 register int idx; | |
502 register Lisp_Object c; | |
503 register Lisp_Object tem; | |
504 register Lisp_Object cmd; | |
505 int metized = 0; | |
2059 | 506 int meta_bit; |
250 | 507 int length; |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
508 struct gcpro gcpro1, gcpro2, gcpro3; |
250 | 509 |
510 keymap = get_keymap (keymap); | |
511 | |
512 if (XTYPE (key) != Lisp_Vector | |
513 && XTYPE (key) != Lisp_String) | |
514 key = wrong_type_argument (Qarrayp, key); | |
515 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
516 length = XFASTINT (Flength (key)); |
250 | 517 if (length == 0) |
518 return Qnil; | |
519 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
520 GCPRO3 (keymap, key, def); |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
521 |
2059 | 522 if (XTYPE (key) == Lisp_Vector) |
523 meta_bit = meta_modifier; | |
524 else | |
525 meta_bit = 0x80; | |
526 | |
250 | 527 idx = 0; |
528 while (1) | |
529 { | |
530 c = Faref (key, make_number (idx)); | |
531 | |
532 if (XTYPE (c) == Lisp_Int | |
2059 | 533 && (XINT (c) & meta_bit) |
250 | 534 && !metized) |
535 { | |
536 c = meta_prefix_char; | |
537 metized = 1; | |
538 } | |
539 else | |
540 { | |
541 if (XTYPE (c) == Lisp_Int) | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
542 XSETINT (c, XINT (c) & ~meta_bit); |
250 | 543 |
544 metized = 0; | |
545 idx++; | |
546 } | |
547 | |
548 if (idx == length) | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
549 RETURN_UNGCPRO (store_in_keymap (keymap, c, def)); |
250 | 550 |
1388
02226bff1476
* keymap.c (initial_define_lispy_key): New function, for defining
Jim Blandy <jimb@redhat.com>
parents:
1315
diff
changeset
|
551 cmd = get_keyelt (access_keymap (keymap, c, 0)); |
250 | 552 |
485 | 553 if (NILP (cmd)) |
250 | 554 { |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
555 cmd = Fmake_sparse_keymap (Qnil); |
250 | 556 store_in_keymap (keymap, c, cmd); |
557 } | |
558 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
559 keymap = get_keymap_1 (cmd, 0, 1); |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
560 if (NILP (keymap)) |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
561 { |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
562 /* We must use Fkey_description rather than just passing key to |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
563 error; key might be a vector, not a string. */ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
564 Lisp_Object description = Fkey_description (key); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
565 |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
566 error ("Key sequence %s uses invalid prefix characters", |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
567 XSTRING (description)->data); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1566
diff
changeset
|
568 } |
250 | 569 } |
570 } | |
571 | |
572 /* Value is number if KEY is too long; NIL if valid but has no definition. */ | |
573 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
574 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0, |
250 | 575 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\ |
576 nil means undefined. See doc of `define-key' for kinds of definitions.\n\ | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
577 \n\ |
250 | 578 A number as value means KEY is \"too long\";\n\ |
579 that is, characters or symbols in it except for the last one\n\ | |
580 fail to be a valid sequence of prefix characters in KEYMAP.\n\ | |
581 The number is how many characters at the front of KEY\n\ | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
582 it takes to reach a non-prefix command.\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
583 \n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
584 Normally, `lookup-key' ignores bindings for t, which act as default\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
585 bindings, used when nothing else in the keymap applies; this makes it\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
586 useable as a general function for probing keymaps. However, if the\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
587 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
588 recognize the default bindings, just as `read-key-sequence' does.") |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
589 (keymap, key, accept_default) |
250 | 590 register Lisp_Object keymap; |
591 Lisp_Object key; | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
592 Lisp_Object accept_default; |
250 | 593 { |
594 register int idx; | |
595 register Lisp_Object tem; | |
596 register Lisp_Object cmd; | |
597 register Lisp_Object c; | |
598 int metized = 0; | |
599 int length; | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
600 int t_ok = ! NILP (accept_default); |
2059 | 601 int meta_bit; |
250 | 602 |
603 keymap = get_keymap (keymap); | |
604 | |
605 if (XTYPE (key) != Lisp_Vector | |
606 && XTYPE (key) != Lisp_String) | |
607 key = wrong_type_argument (Qarrayp, key); | |
608 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
609 length = XFASTINT (Flength (key)); |
250 | 610 if (length == 0) |
611 return keymap; | |
612 | |
2059 | 613 if (XTYPE (key) == Lisp_Vector) |
614 meta_bit = meta_modifier; | |
615 else | |
616 meta_bit = 0x80; | |
617 | |
250 | 618 idx = 0; |
619 while (1) | |
620 { | |
621 c = Faref (key, make_number (idx)); | |
622 | |
623 if (XTYPE (c) == Lisp_Int | |
2059 | 624 && (XINT (c) & meta_bit) |
250 | 625 && !metized) |
626 { | |
627 c = meta_prefix_char; | |
628 metized = 1; | |
629 } | |
630 else | |
631 { | |
632 if (XTYPE (c) == Lisp_Int) | |
2059 | 633 XSETINT (c, XINT (c) & ~meta_bit); |
250 | 634 |
635 metized = 0; | |
636 idx++; | |
637 } | |
638 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
639 cmd = get_keyelt (access_keymap (keymap, c, t_ok)); |
250 | 640 if (idx == length) |
641 return cmd; | |
642 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
643 keymap = get_keymap_1 (cmd, 0, 0); |
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
644 if (NILP (keymap)) |
250 | 645 return make_number (idx); |
646 | |
647 QUIT; | |
648 } | |
649 } | |
650 | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
651 /* Append a key to the end of a key sequence. We always make a vector. */ |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
652 |
250 | 653 Lisp_Object |
654 append_key (key_sequence, key) | |
655 Lisp_Object key_sequence, key; | |
656 { | |
657 Lisp_Object args[2]; | |
658 | |
659 args[0] = key_sequence; | |
660 | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
661 args[1] = Fcons (key, Qnil); |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
662 return Fvconcat (2, args); |
250 | 663 } |
664 | |
665 | |
465 | 666 /* Global, local, and minor mode keymap stuff. */ |
667 | |
485 | 668 /* We can't put these variables inside current_minor_maps, since under |
517 | 669 some systems, static gets macro-defined to be the empty string. |
670 Ickypoo. */ | |
485 | 671 static Lisp_Object *cmm_modes, *cmm_maps; |
672 static int cmm_size; | |
673 | |
465 | 674 /* Store a pointer to an array of the keymaps of the currently active |
675 minor modes in *buf, and return the number of maps it contains. | |
676 | |
677 This function always returns a pointer to the same buffer, and may | |
678 free or reallocate it, so if you want to keep it for a long time or | |
679 hand it out to lisp code, copy it. This procedure will be called | |
680 for every key sequence read, so the nice lispy approach (return a | |
681 new assoclist, list, what have you) for each invocation would | |
682 result in a lot of consing over time. | |
683 | |
684 If we used xrealloc/xmalloc and ran out of memory, they would throw | |
685 back to the command loop, which would try to read a key sequence, | |
686 which would call this function again, resulting in an infinite | |
687 loop. Instead, we'll use realloc/malloc and silently truncate the | |
688 list, let the key sequence be read, and hope some other piece of | |
689 code signals the error. */ | |
690 int | |
691 current_minor_maps (modeptr, mapptr) | |
692 Lisp_Object **modeptr, **mapptr; | |
693 { | |
694 int i = 0; | |
517 | 695 Lisp_Object alist, assoc, var, val; |
465 | 696 |
697 for (alist = Vminor_mode_map_alist; | |
698 CONSP (alist); | |
699 alist = XCONS (alist)->cdr) | |
700 if (CONSP (assoc = XCONS (alist)->car) | |
701 && XTYPE (var = XCONS (assoc)->car) == Lisp_Symbol | |
517 | 702 && ! EQ ((val = find_symbol_value (var)), Qunbound) |
703 && ! NILP (val)) | |
465 | 704 { |
485 | 705 if (i >= cmm_size) |
465 | 706 { |
707 Lisp_Object *newmodes, *newmaps; | |
708 | |
485 | 709 if (cmm_maps) |
465 | 710 { |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2358
diff
changeset
|
711 BLOCK_INPUT; |
485 | 712 newmodes = (Lisp_Object *) realloc (cmm_modes, cmm_size *= 2); |
713 newmaps = (Lisp_Object *) realloc (cmm_maps, cmm_size); | |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2358
diff
changeset
|
714 UNBLOCK_INPUT; |
465 | 715 } |
716 else | |
717 { | |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2358
diff
changeset
|
718 BLOCK_INPUT; |
485 | 719 newmodes = (Lisp_Object *) malloc (cmm_size = 30); |
720 newmaps = (Lisp_Object *) malloc (cmm_size); | |
2439
b6c62e4abf59
Put interrupt input blocking in a separate file from xterm.h.
Jim Blandy <jimb@redhat.com>
parents:
2358
diff
changeset
|
721 UNBLOCK_INPUT; |
465 | 722 } |
723 | |
724 if (newmaps && newmodes) | |
725 { | |
485 | 726 cmm_modes = newmodes; |
727 cmm_maps = newmaps; | |
465 | 728 } |
729 else | |
730 break; | |
731 } | |
485 | 732 cmm_modes[i] = var; |
733 cmm_maps [i] = XCONS (assoc)->cdr; | |
465 | 734 i++; |
735 } | |
736 | |
485 | 737 if (modeptr) *modeptr = cmm_modes; |
738 if (mapptr) *mapptr = cmm_maps; | |
465 | 739 return i; |
740 } | |
741 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
742 DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0, |
250 | 743 "Return the binding for command KEY in current keymaps.\n\ |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
744 KEY is a string or vector, a sequence of keystrokes.\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
745 The binding is probably a symbol with a function definition.\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
746 \n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
747 Normally, `key-binding' ignores bindings for t, which act as default\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
748 bindings, used when nothing else in the keymap applies; this makes it\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
749 useable as a general function for probing keymaps. However, if the\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
750 third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
751 recognize the default bindings, just as `read-key-sequence' does.") |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
752 (key, accept_default) |
250 | 753 Lisp_Object key; |
754 { | |
465 | 755 Lisp_Object *maps, value; |
756 int nmaps, i; | |
757 | |
758 nmaps = current_minor_maps (0, &maps); | |
759 for (i = 0; i < nmaps; i++) | |
485 | 760 if (! NILP (maps[i])) |
465 | 761 { |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
762 value = Flookup_key (maps[i], key, accept_default); |
485 | 763 if (! NILP (value) && XTYPE (value) != Lisp_Int) |
465 | 764 return value; |
765 } | |
766 | |
485 | 767 if (! NILP (current_buffer->keymap)) |
250 | 768 { |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
769 value = Flookup_key (current_buffer->keymap, key, accept_default); |
485 | 770 if (! NILP (value) && XTYPE (value) != Lisp_Int) |
250 | 771 return value; |
772 } | |
465 | 773 |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
774 value = Flookup_key (current_global_map, key, accept_default); |
485 | 775 if (! NILP (value) && XTYPE (value) != Lisp_Int) |
465 | 776 return value; |
777 | |
778 return Qnil; | |
250 | 779 } |
780 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
781 DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0, |
250 | 782 "Return the binding for command KEYS in current local keymap only.\n\ |
783 KEYS is a string, a sequence of keystrokes.\n\ | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
784 The binding is probably a symbol with a function definition.\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
785 \n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
786 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
787 bindings; see the description of `lookup-key' for more details about this.") |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
788 (keys, accept_default) |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
789 Lisp_Object keys, accept_default; |
250 | 790 { |
791 register Lisp_Object map; | |
792 map = current_buffer->keymap; | |
485 | 793 if (NILP (map)) |
250 | 794 return Qnil; |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
795 return Flookup_key (map, keys, accept_default); |
250 | 796 } |
797 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
798 DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0, |
250 | 799 "Return the binding for command KEYS in current global keymap only.\n\ |
800 KEYS is a string, a sequence of keystrokes.\n\ | |
517 | 801 The binding is probably a symbol with a function definition.\n\ |
802 This function's return values are the same as those of lookup-key\n\ | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
803 (which see).\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
804 \n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
805 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
806 bindings; see the description of `lookup-key' for more details about this.") |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
807 (keys, accept_default) |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
808 Lisp_Object keys, accept_default; |
250 | 809 { |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
810 return Flookup_key (current_global_map, keys, accept_default); |
250 | 811 } |
812 | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
813 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0, |
465 | 814 "Find the visible minor mode bindings of KEY.\n\ |
815 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\ | |
816 the symbol which names the minor mode binding KEY, and BINDING is\n\ | |
817 KEY's definition in that mode. In particular, if KEY has no\n\ | |
818 minor-mode bindings, return nil. If the first binding is a\n\ | |
819 non-prefix, all subsequent bindings will be omitted, since they would\n\ | |
820 be ignored. Similarly, the list doesn't include non-prefix bindings\n\ | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
821 that come after prefix bindings.\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
822 \n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
823 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\ |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
824 bindings; see the description of `lookup-key' for more details about this.") |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
825 (key, accept_default) |
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
826 Lisp_Object key, accept_default; |
465 | 827 { |
828 Lisp_Object *modes, *maps; | |
829 int nmaps; | |
830 Lisp_Object binding; | |
831 int i, j; | |
832 | |
833 nmaps = current_minor_maps (&modes, &maps); | |
834 | |
835 for (i = j = 0; i < nmaps; i++) | |
485 | 836 if (! NILP (maps[i]) |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
837 && ! NILP (binding = Flookup_key (maps[i], key, accept_default)) |
465 | 838 && XTYPE (binding) != Lisp_Int) |
839 { | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
840 if (! NILP (get_keymap (binding))) |
465 | 841 maps[j++] = Fcons (modes[i], binding); |
842 else if (j == 0) | |
843 return Fcons (Fcons (modes[i], binding), Qnil); | |
844 } | |
845 | |
846 return Flist (j, maps); | |
847 } | |
848 | |
250 | 849 DEFUN ("global-set-key", Fglobal_set_key, Sglobal_set_key, 2, 2, |
850 "kSet key globally: \nCSet key %s to command: ", | |
851 "Give KEY a global binding as COMMAND.\n\ | |
852 COMMAND is a symbol naming an interactively-callable function.\n\ | |
853 KEY is a string representing a sequence of keystrokes.\n\ | |
854 Note that if KEY has a local binding in the current buffer\n\ | |
855 that local binding will continue to shadow any global binding.") | |
856 (keys, function) | |
857 Lisp_Object keys, function; | |
858 { | |
859 if (XTYPE (keys) != Lisp_Vector | |
860 && XTYPE (keys) != Lisp_String) | |
861 keys = wrong_type_argument (Qarrayp, keys); | |
862 | |
863 Fdefine_key (current_global_map, keys, function); | |
864 return Qnil; | |
865 } | |
866 | |
867 DEFUN ("local-set-key", Flocal_set_key, Slocal_set_key, 2, 2, | |
868 "kSet key locally: \nCSet key %s locally to command: ", | |
869 "Give KEY a local binding as COMMAND.\n\ | |
870 COMMAND is a symbol naming an interactively-callable function.\n\ | |
871 KEY is a string representing a sequence of keystrokes.\n\ | |
872 The binding goes in the current buffer's local map,\n\ | |
873 which is shared with other buffers in the same major mode.") | |
874 (keys, function) | |
875 Lisp_Object keys, function; | |
876 { | |
877 register Lisp_Object map; | |
878 map = current_buffer->keymap; | |
485 | 879 if (NILP (map)) |
250 | 880 { |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
881 map = Fmake_sparse_keymap (Qnil); |
250 | 882 current_buffer->keymap = map; |
883 } | |
884 | |
885 if (XTYPE (keys) != Lisp_Vector | |
886 && XTYPE (keys) != Lisp_String) | |
887 keys = wrong_type_argument (Qarrayp, keys); | |
888 | |
889 Fdefine_key (map, keys, function); | |
890 return Qnil; | |
891 } | |
892 | |
893 DEFUN ("global-unset-key", Fglobal_unset_key, Sglobal_unset_key, | |
894 1, 1, "kUnset key globally: ", | |
895 "Remove global binding of KEY.\n\ | |
896 KEY is a string representing a sequence of keystrokes.") | |
897 (keys) | |
898 Lisp_Object keys; | |
899 { | |
900 return Fglobal_set_key (keys, Qnil); | |
901 } | |
902 | |
903 DEFUN ("local-unset-key", Flocal_unset_key, Slocal_unset_key, 1, 1, | |
904 "kUnset key locally: ", | |
905 "Remove local binding of KEY.\n\ | |
906 KEY is a string representing a sequence of keystrokes.") | |
907 (keys) | |
908 Lisp_Object keys; | |
909 { | |
485 | 910 if (!NILP (current_buffer->keymap)) |
250 | 911 Flocal_set_key (keys, Qnil); |
912 return Qnil; | |
913 } | |
914 | |
915 DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 2, 0, | |
2652
90485f37bfc3
* keymap.c (Fdefine_prefix_command): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
2439
diff
changeset
|
916 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\ |
250 | 917 A new sparse keymap is stored as COMMAND's function definition and its value.\n\ |
362 | 918 If a second optional argument MAPVAR is given, the map is stored as\n\ |
919 its value instead of as COMMAND's value; but COMMAND is still defined\n\ | |
920 as a function.") | |
250 | 921 (name, mapvar) |
922 Lisp_Object name, mapvar; | |
923 { | |
924 Lisp_Object map; | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
925 map = Fmake_sparse_keymap (Qnil); |
250 | 926 Ffset (name, map); |
485 | 927 if (!NILP (mapvar)) |
250 | 928 Fset (mapvar, map); |
929 else | |
930 Fset (name, map); | |
931 return name; | |
932 } | |
933 | |
934 DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0, | |
935 "Select KEYMAP as the global keymap.") | |
936 (keymap) | |
937 Lisp_Object keymap; | |
938 { | |
939 keymap = get_keymap (keymap); | |
940 current_global_map = keymap; | |
941 return Qnil; | |
942 } | |
943 | |
944 DEFUN ("use-local-map", Fuse_local_map, Suse_local_map, 1, 1, 0, | |
945 "Select KEYMAP as the local keymap.\n\ | |
946 If KEYMAP is nil, that means no local keymap.") | |
947 (keymap) | |
948 Lisp_Object keymap; | |
949 { | |
485 | 950 if (!NILP (keymap)) |
250 | 951 keymap = get_keymap (keymap); |
952 | |
953 current_buffer->keymap = keymap; | |
954 | |
955 return Qnil; | |
956 } | |
957 | |
958 DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 0, 0, | |
959 "Return current buffer's local keymap, or nil if it has none.") | |
960 () | |
961 { | |
962 return current_buffer->keymap; | |
963 } | |
964 | |
965 DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0, | |
966 "Return the current global keymap.") | |
967 () | |
968 { | |
969 return current_global_map; | |
970 } | |
465 | 971 |
972 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_maps, 0, 0, 0, | |
973 "Return a list of keymaps for the minor modes of the current buffer.") | |
974 () | |
975 { | |
976 Lisp_Object *maps; | |
977 int nmaps = current_minor_maps (0, &maps); | |
978 | |
979 return Flist (nmaps, maps); | |
980 } | |
250 | 981 |
465 | 982 /* Help functions for describing and documenting keymaps. */ |
983 | |
250 | 984 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps, |
985 1, 1, 0, | |
986 "Find all keymaps accessible via prefix characters from KEYMAP.\n\ | |
987 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\ | |
988 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\ | |
989 so that the KEYS increase in length. The first element is (\"\" . KEYMAP).") | |
990 (startmap) | |
991 Lisp_Object startmap; | |
992 { | |
993 Lisp_Object maps, tail; | |
994 | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
995 maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil), |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
996 get_keymap (startmap)), |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
997 Qnil); |
250 | 998 |
999 /* For each map in the list maps, | |
1000 look at any other maps it points to, | |
1001 and stick them at the end if they are not already in the list. | |
1002 | |
1003 This is a breadth-first traversal, where tail is the queue of | |
1004 nodes, and maps accumulates a list of all nodes visited. */ | |
1005 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1006 for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr) |
250 | 1007 { |
1008 register Lisp_Object thisseq = Fcar (Fcar (tail)); | |
1009 register Lisp_Object thismap = Fcdr (Fcar (tail)); | |
1010 Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1); | |
1011 | |
1012 /* Does the current sequence end in the meta-prefix-char? */ | |
1013 int is_metized = (XINT (last) >= 0 | |
1014 && EQ (Faref (thisseq, last), meta_prefix_char)); | |
1015 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1016 for (; CONSP (thismap); thismap = XCONS (thismap)->cdr) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1017 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1018 Lisp_Object elt = XCONS (thismap)->car; |
250 | 1019 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1020 QUIT; |
250 | 1021 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1022 if (XTYPE (elt) == Lisp_Vector) |
250 | 1023 { |
1024 register int i; | |
1025 | |
1026 /* Vector keymap. Scan all the elements. */ | |
1027 for (i = 0; i < DENSE_TABLE_SIZE; i++) | |
1028 { | |
1029 register Lisp_Object tem; | |
1030 register Lisp_Object cmd; | |
1031 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1032 cmd = get_keyelt (XVECTOR (elt)->contents[i]); |
485 | 1033 if (NILP (cmd)) continue; |
250 | 1034 tem = Fkeymapp (cmd); |
485 | 1035 if (!NILP (tem)) |
250 | 1036 { |
1037 cmd = get_keymap (cmd); | |
1038 /* Ignore keymaps that are already added to maps. */ | |
1039 tem = Frassq (cmd, maps); | |
485 | 1040 if (NILP (tem)) |
250 | 1041 { |
1042 /* If the last key in thisseq is meta-prefix-char, | |
1043 turn it into a meta-ized keystroke. We know | |
1044 that the event we're about to append is an | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1045 ascii keystroke since we're processing a |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1046 keymap table. */ |
250 | 1047 if (is_metized) |
1048 { | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1049 int meta_bit = meta_modifier; |
250 | 1050 tem = Fcopy_sequence (thisseq); |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1051 |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1052 Faset (tem, last, make_number (i | meta_bit)); |
250 | 1053 |
1054 /* This new sequence is the same length as | |
1055 thisseq, so stick it in the list right | |
1056 after this one. */ | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1057 XCONS (tail)->cdr |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1058 = Fcons (Fcons (tem, cmd), XCONS (tail)->cdr); |
250 | 1059 } |
1060 else | |
1061 { | |
1062 tem = append_key (thisseq, make_number (i)); | |
1063 nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil)); | |
1064 } | |
1065 } | |
1066 } | |
1067 } | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1068 } |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1069 else if (CONSP (elt)) |
250 | 1070 { |
1071 register Lisp_Object cmd = get_keyelt (XCONS (elt)->cdr); | |
1072 register Lisp_Object tem; | |
1073 | |
1074 /* Ignore definitions that aren't keymaps themselves. */ | |
1075 tem = Fkeymapp (cmd); | |
485 | 1076 if (!NILP (tem)) |
250 | 1077 { |
1078 /* Ignore keymaps that have been seen already. */ | |
1079 cmd = get_keymap (cmd); | |
1080 tem = Frassq (cmd, maps); | |
485 | 1081 if (NILP (tem)) |
250 | 1082 { |
1083 /* let elt be the event defined by this map entry. */ | |
1084 elt = XCONS (elt)->car; | |
1085 | |
1086 /* If the last key in thisseq is meta-prefix-char, and | |
1087 this entry is a binding for an ascii keystroke, | |
1088 turn it into a meta-ized keystroke. */ | |
1089 if (is_metized && XTYPE (elt) == Lisp_Int) | |
1090 { | |
1091 tem = Fcopy_sequence (thisseq); | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1092 Faset (tem, last, |
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1093 make_number (XINT (elt) | meta_modifier)); |
250 | 1094 |
1095 /* This new sequence is the same length as | |
1096 thisseq, so stick it in the list right | |
1097 after this one. */ | |
1098 XCONS (tail)->cdr = | |
1099 Fcons (Fcons (tem, cmd), XCONS (tail)->cdr); | |
1100 } | |
1101 else | |
1102 nconc2 (tail, | |
1103 Fcons (Fcons (append_key (thisseq, elt), cmd), | |
1104 Qnil)); | |
1105 } | |
1106 } | |
1107 } | |
1108 } | |
1109 } | |
1110 | |
1111 return maps; | |
1112 } | |
1113 | |
1114 Lisp_Object Qsingle_key_description, Qkey_description; | |
1115 | |
1116 DEFUN ("key-description", Fkey_description, Skey_description, 1, 1, 0, | |
1117 "Return a pretty description of key-sequence KEYS.\n\ | |
1118 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\ | |
1119 spaces are put between sequence elements, etc.") | |
1120 (keys) | |
1121 Lisp_Object keys; | |
1122 { | |
2059 | 1123 if (XTYPE (keys) == Lisp_String) |
1124 { | |
1125 Lisp_Object vector; | |
1126 int i; | |
1127 vector = Fmake_vector (Flength (keys), Qnil); | |
1128 for (i = 0; i < XSTRING (keys)->size; i++) | |
1129 { | |
1130 if (XSTRING (keys)->data[i] & 0x80) | |
1131 XFASTINT (XVECTOR (vector)->contents[i]) | |
1132 = meta_modifier | (XSTRING (keys)->data[i] & ~0x80); | |
1133 else | |
1134 XFASTINT (XVECTOR (vector)->contents[i]) | |
1135 = XSTRING (keys)->data[i]; | |
1136 } | |
1137 keys = vector; | |
1138 } | |
250 | 1139 return Fmapconcat (Qsingle_key_description, keys, build_string (" ")); |
1140 } | |
1141 | |
1142 char * | |
1143 push_key_description (c, p) | |
1144 register unsigned int c; | |
1145 register char *p; | |
1146 { | |
2343
ddb30eaf2f56
(push_key_description): Ignore bits above meta_modifier.
Richard M. Stallman <rms@gnu.org>
parents:
2093
diff
changeset
|
1147 /* Clear all the meaningless bits above the meta bit. */ |
ddb30eaf2f56
(push_key_description): Ignore bits above meta_modifier.
Richard M. Stallman <rms@gnu.org>
parents:
2093
diff
changeset
|
1148 c &= meta_modifier | ~ - meta_modifier; |
ddb30eaf2f56
(push_key_description): Ignore bits above meta_modifier.
Richard M. Stallman <rms@gnu.org>
parents:
2093
diff
changeset
|
1149 |
2059 | 1150 if (c & alt_modifier) |
1151 { | |
1152 *p++ = 'A'; | |
1153 *p++ = '-'; | |
1154 c -= alt_modifier; | |
1155 } | |
1156 if (c & ctrl_modifier) | |
1157 { | |
1158 *p++ = 'C'; | |
1159 *p++ = '-'; | |
1160 c -= ctrl_modifier; | |
1161 } | |
1162 if (c & hyper_modifier) | |
1163 { | |
1164 *p++ = 'H'; | |
1165 *p++ = '-'; | |
1166 c -= hyper_modifier; | |
1167 } | |
1168 if (c & meta_modifier) | |
250 | 1169 { |
1170 *p++ = 'M'; | |
1171 *p++ = '-'; | |
2059 | 1172 c -= meta_modifier; |
1173 } | |
1174 if (c & shift_modifier) | |
1175 { | |
1176 *p++ = 'S'; | |
1177 *p++ = '-'; | |
1178 c -= shift_modifier; | |
1179 } | |
1180 if (c & super_modifier) | |
1181 { | |
1182 *p++ = 's'; | |
1183 *p++ = '-'; | |
1184 c -= super_modifier; | |
250 | 1185 } |
1186 if (c < 040) | |
1187 { | |
1188 if (c == 033) | |
1189 { | |
1190 *p++ = 'E'; | |
1191 *p++ = 'S'; | |
1192 *p++ = 'C'; | |
1193 } | |
2059 | 1194 else if (c == '\t') |
250 | 1195 { |
1196 *p++ = 'T'; | |
1197 *p++ = 'A'; | |
1198 *p++ = 'B'; | |
1199 } | |
1200 else if (c == Ctl('J')) | |
1201 { | |
1202 *p++ = 'L'; | |
1203 *p++ = 'F'; | |
1204 *p++ = 'D'; | |
1205 } | |
1206 else if (c == Ctl('M')) | |
1207 { | |
1208 *p++ = 'R'; | |
1209 *p++ = 'E'; | |
1210 *p++ = 'T'; | |
1211 } | |
1212 else | |
1213 { | |
1214 *p++ = 'C'; | |
1215 *p++ = '-'; | |
1216 if (c > 0 && c <= Ctl ('Z')) | |
1217 *p++ = c + 0140; | |
1218 else | |
1219 *p++ = c + 0100; | |
1220 } | |
1221 } | |
1222 else if (c == 0177) | |
1223 { | |
1224 *p++ = 'D'; | |
1225 *p++ = 'E'; | |
1226 *p++ = 'L'; | |
1227 } | |
1228 else if (c == ' ') | |
1229 { | |
1230 *p++ = 'S'; | |
1231 *p++ = 'P'; | |
1232 *p++ = 'C'; | |
1233 } | |
2059 | 1234 else if (c < 256) |
1235 *p++ = c; | |
250 | 1236 else |
2059 | 1237 { |
1238 *p++ = '\\'; | |
1239 *p++ = (7 & (c >> 15)) + '0'; | |
1240 *p++ = (7 & (c >> 12)) + '0'; | |
1241 *p++ = (7 & (c >> 9)) + '0'; | |
1242 *p++ = (7 & (c >> 6)) + '0'; | |
1243 *p++ = (7 & (c >> 3)) + '0'; | |
1244 *p++ = (7 & (c >> 0)) + '0'; | |
1245 } | |
250 | 1246 |
1247 return p; | |
1248 } | |
1249 | |
1250 DEFUN ("single-key-description", Fsingle_key_description, Ssingle_key_description, 1, 1, 0, | |
1251 "Return a pretty description of command character KEY.\n\ | |
1252 Control characters turn into C-whatever, etc.") | |
1253 (key) | |
1254 Lisp_Object key; | |
1255 { | |
2059 | 1256 char tem[20]; |
250 | 1257 |
1315
884c3d7e7172
* keymap.c (access_keymap, store_in_keymap,
Jim Blandy <jimb@redhat.com>
parents:
1264
diff
changeset
|
1258 key = EVENT_HEAD (key); |
517 | 1259 |
250 | 1260 switch (XTYPE (key)) |
1261 { | |
1262 case Lisp_Int: /* Normal character */ | |
2059 | 1263 *push_key_description (XUINT (key), tem) = 0; |
250 | 1264 return build_string (tem); |
1265 | |
1266 case Lisp_Symbol: /* Function key or event-symbol */ | |
1267 return Fsymbol_name (key); | |
1268 | |
1269 default: | |
1270 error ("KEY must be an integer, cons, or symbol."); | |
1271 } | |
1272 } | |
1273 | |
1274 char * | |
1275 push_text_char_description (c, p) | |
1276 register unsigned int c; | |
1277 register char *p; | |
1278 { | |
1279 if (c >= 0200) | |
1280 { | |
1281 *p++ = 'M'; | |
1282 *p++ = '-'; | |
1283 c -= 0200; | |
1284 } | |
1285 if (c < 040) | |
1286 { | |
1287 *p++ = '^'; | |
1288 *p++ = c + 64; /* 'A' - 1 */ | |
1289 } | |
1290 else if (c == 0177) | |
1291 { | |
1292 *p++ = '^'; | |
1293 *p++ = '?'; | |
1294 } | |
1295 else | |
1296 *p++ = c; | |
1297 return p; | |
1298 } | |
1299 | |
1300 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0, | |
1301 "Return a pretty description of file-character CHAR.\n\ | |
1302 Control characters turn into \"^char\", etc.") | |
1303 (chr) | |
1304 Lisp_Object chr; | |
1305 { | |
1306 char tem[6]; | |
1307 | |
1308 CHECK_NUMBER (chr, 0); | |
1309 | |
1310 *push_text_char_description (XINT (chr) & 0377, tem) = 0; | |
1311 | |
1312 return build_string (tem); | |
1313 } | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1314 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1315 /* Return non-zero if SEQ contains only ASCII characters, perhaps with |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1316 a meta bit. */ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1317 static int |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1318 ascii_sequence_p (seq) |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1319 Lisp_Object seq; |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1320 { |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1321 Lisp_Object i; |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1322 int len = XINT (Flength (seq)); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1323 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1324 for (XFASTINT (i) = 0; XFASTINT (i) < len; XFASTINT (i)++) |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1325 { |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1326 Lisp_Object elt = Faref (seq, i); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1327 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1328 if (XTYPE (elt) != Lisp_Int |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1329 || (XUINT (elt) & ~CHAR_META) >= 0x80) |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1330 return 0; |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1331 } |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1332 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1333 return 1; |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1334 } |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1335 |
250 | 1336 |
465 | 1337 /* where-is - finding a command in a set of keymaps. */ |
1338 | |
250 | 1339 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0, |
1340 "Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\ | |
1341 If KEYMAP is nil, search only KEYMAP1.\n\ | |
1342 If KEYMAP1 is nil, use the current global map.\n\ | |
1343 \n\ | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1344 If optional 4th arg FIRSTONLY is non-nil, return a string representing\n\ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1345 the first key sequence found, rather than a list of all possible key\n\ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1346 sequences. If FIRSTONLY is t, avoid key sequences which use non-ASCII\n\ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1347 keys and therefore may not be usable on ASCII terminals. If FIRSTONLY\n\ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1348 is the symbol `non-ascii', return the first binding found, no matter\n\ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1349 what its components.\n\ |
250 | 1350 \n\ |
1351 If optional 5th arg NOINDIRECT is non-nil, don't follow indirections\n\ | |
1352 to other keymaps or slots. This makes it possible to search for an\n\ | |
1353 indirect definition itself.") | |
1354 (definition, local_keymap, global_keymap, firstonly, noindirect) | |
1355 Lisp_Object definition, local_keymap, global_keymap; | |
1356 Lisp_Object firstonly, noindirect; | |
1357 { | |
1358 register Lisp_Object maps; | |
1359 Lisp_Object found; | |
1360 | |
485 | 1361 if (NILP (global_keymap)) |
250 | 1362 global_keymap = current_global_map; |
1363 | |
485 | 1364 if (!NILP (local_keymap)) |
250 | 1365 maps = nconc2 (Faccessible_keymaps (get_keymap (local_keymap)), |
1366 Faccessible_keymaps (get_keymap (global_keymap))); | |
1367 else | |
1368 maps = Faccessible_keymaps (get_keymap (global_keymap)); | |
1369 | |
1370 found = Qnil; | |
1371 | |
485 | 1372 for (; !NILP (maps); maps = Fcdr (maps)) |
250 | 1373 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1374 /* Key sequence to reach map */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1375 register Lisp_Object this = Fcar (Fcar (maps)); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1376 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1377 /* The map that it reaches */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1378 register Lisp_Object map = Fcdr (Fcar (maps)); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1379 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1380 /* If Fcar (map) is a VECTOR, the current element within that vector. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1381 int i = 0; |
250 | 1382 |
1383 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into | |
1384 [M-CHAR] sequences, check if last character of the sequence | |
1385 is the meta-prefix char. */ | |
1386 Lisp_Object last = make_number (XINT (Flength (this)) - 1); | |
1387 int last_is_meta = (XINT (last) >= 0 | |
1388 && EQ (Faref (this, last), meta_prefix_char)); | |
1389 | |
1236
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1390 QUIT; |
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1391 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1392 while (CONSP (map)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1393 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1394 /* Because the code we want to run on each binding is rather |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1395 large, we don't want to have two separate loop bodies for |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1396 sparse keymap bindings and tables; we want to iterate one |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1397 loop body over both keymap and vector bindings. |
250 | 1398 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1399 For this reason, if Fcar (map) is a vector, we don't |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1400 advance map to the next element until i indicates that we |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1401 have finished off the vector. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1402 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1403 Lisp_Object elt = XCONS (map)->car; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1404 Lisp_Object key, binding, sequence; |
250 | 1405 |
1236
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1406 QUIT; |
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1407 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1408 /* Set key and binding to the current key and binding, and |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1409 advance map and i to the next binding. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1410 if (XTYPE (elt) == Lisp_Vector) |
250 | 1411 { |
1412 /* In a vector, look at each element. */ | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1413 binding = XVECTOR (elt)->contents[i]; |
250 | 1414 XFASTINT (key) = i; |
1415 i++; | |
1416 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1417 /* If we've just finished scanning a vector, advance map |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1418 to the next element, and reset i in anticipation of the |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1419 next vector we may find. */ |
250 | 1420 if (i >= DENSE_TABLE_SIZE) |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1421 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1422 map = XCONS (map)->cdr; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1423 i = 0; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1424 } |
250 | 1425 } |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1426 else if (CONSP (elt)) |
250 | 1427 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1428 key = Fcar (Fcar (map)); |
250 | 1429 binding = Fcdr (Fcar (map)); |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1430 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1431 map = XCONS (map)->cdr; |
250 | 1432 } |
1433 else | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1434 /* We want to ignore keymap elements that are neither |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1435 vectors nor conses. */ |
1236
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1436 { |
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1437 map = XCONS (map)->cdr; |
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1438 continue; |
5e8c234e5f03
* keymap.c (access_keymap): Remove code to notice bindings for
Jim Blandy <jimb@redhat.com>
parents:
1209
diff
changeset
|
1439 } |
250 | 1440 |
1441 /* Search through indirections unless that's not wanted. */ | |
485 | 1442 if (NILP (noindirect)) |
250 | 1443 binding = get_keyelt (binding); |
1444 | |
1445 /* End this iteration if this element does not match | |
1446 the target. */ | |
1447 | |
1448 if (XTYPE (definition) == Lisp_Cons) | |
1449 { | |
1450 Lisp_Object tem; | |
1451 tem = Fequal (binding, definition); | |
485 | 1452 if (NILP (tem)) |
250 | 1453 continue; |
1454 } | |
1455 else | |
1456 if (!EQ (binding, definition)) | |
1457 continue; | |
1458 | |
1459 /* We have found a match. | |
1460 Construct the key sequence where we found it. */ | |
1461 if (XTYPE (key) == Lisp_Int && last_is_meta) | |
1462 { | |
1463 sequence = Fcopy_sequence (this); | |
2093
ce8bad247b1a
(Fdefine_key): Use proper meta-bit to clear.
Richard M. Stallman <rms@gnu.org>
parents:
2059
diff
changeset
|
1464 Faset (sequence, last, make_number (XINT (key) | meta_modifier)); |
250 | 1465 } |
1466 else | |
1467 sequence = append_key (this, key); | |
1468 | |
1469 /* Verify that this key binding is not shadowed by another | |
1470 binding for the same key, before we say it exists. | |
1471 | |
1472 Mechanism: look for local definition of this key and if | |
1473 it is defined and does not match what we found then | |
1474 ignore this key. | |
1475 | |
1476 Either nil or number as value from Flookup_key | |
1477 means undefined. */ | |
485 | 1478 if (!NILP (local_keymap)) |
250 | 1479 { |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
1480 binding = Flookup_key (local_keymap, sequence, Qnil); |
485 | 1481 if (!NILP (binding) && XTYPE (binding) != Lisp_Int) |
250 | 1482 { |
1483 if (XTYPE (definition) == Lisp_Cons) | |
1484 { | |
1485 Lisp_Object tem; | |
1486 tem = Fequal (binding, definition); | |
485 | 1487 if (NILP (tem)) |
250 | 1488 continue; |
1489 } | |
1490 else | |
1491 if (!EQ (binding, definition)) | |
1492 continue; | |
1493 } | |
1494 } | |
1495 | |
1496 /* It is a true unshadowed match. Record it. */ | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1497 found = Fcons (sequence, found); |
250 | 1498 |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1499 /* If firstonly is Qnon_ascii, then we can return the first |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1500 binding we find. If firstonly is not Qnon_ascii but not |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1501 nil, then we should return the first ascii-only binding |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1502 we find. */ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1503 if (EQ (firstonly, Qnon_ascii)) |
250 | 1504 return sequence; |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1505 else if (! NILP (firstonly) && ascii_sequence_p (sequence)) |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1506 return sequence; |
250 | 1507 } |
1508 } | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1509 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1510 found = Fnreverse (found); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1511 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1512 /* firstonly may have been t, but we may have gone all the way through |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1513 the keymaps without finding an all-ASCII key sequence. So just |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1514 return the best we could find. */ |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1515 if (! NILP (firstonly)) |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1516 return Fcar (found); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1517 |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
1518 return found; |
250 | 1519 } |
1520 | |
1521 /* Return a string listing the keys and buttons that run DEFINITION. */ | |
1522 | |
1523 static Lisp_Object | |
1524 where_is_string (definition) | |
1525 Lisp_Object definition; | |
1526 { | |
1527 register Lisp_Object keys, keys1; | |
1528 | |
1529 keys = Fwhere_is_internal (definition, | |
1530 current_buffer->keymap, Qnil, Qnil, Qnil); | |
1531 keys1 = Fmapconcat (Qkey_description, keys, build_string (", ")); | |
1532 | |
1533 return keys1; | |
1534 } | |
1535 | |
1536 DEFUN ("where-is", Fwhere_is, Swhere_is, 1, 1, "CWhere is command: ", | |
1537 "Print message listing key sequences that invoke specified command.\n\ | |
1538 Argument is a command definition, usually a symbol with a function definition.") | |
1539 (definition) | |
1540 Lisp_Object definition; | |
1541 { | |
1542 register Lisp_Object string; | |
1543 | |
1544 CHECK_SYMBOL (definition, 0); | |
1545 string = where_is_string (definition); | |
1546 | |
1547 if (XSTRING (string)->size) | |
1548 message ("%s is on %s", XSYMBOL (definition)->name->data, | |
1549 XSTRING (string)->data); | |
1550 else | |
1551 message ("%s is not on any key", XSYMBOL (definition)->name->data); | |
1552 return Qnil; | |
1553 } | |
1554 | |
465 | 1555 /* describe-bindings - summarizing all the bindings in a set of keymaps. */ |
1556 | |
250 | 1557 DEFUN ("describe-bindings", Fdescribe_bindings, Sdescribe_bindings, 0, 0, "", |
1558 "Show a list of all defined keys, and their definitions.\n\ | |
1559 The list is put in a buffer, which is displayed.") | |
1560 () | |
1561 { | |
1562 register Lisp_Object thisbuf; | |
1563 XSET (thisbuf, Lisp_Buffer, current_buffer); | |
1564 internal_with_output_to_temp_buffer ("*Help*", | |
1565 describe_buffer_bindings, | |
1566 thisbuf); | |
1567 return Qnil; | |
1568 } | |
1569 | |
1570 static Lisp_Object | |
1571 describe_buffer_bindings (descbuf) | |
1572 Lisp_Object descbuf; | |
1573 { | |
1574 register Lisp_Object start1, start2; | |
1575 | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1576 char *key_heading |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1577 = "\ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1578 key binding\n\ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1579 --- -------\n"; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1580 char *alternate_heading |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1581 = "\ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1582 Alternate Characters (use anywhere the nominal character is listed):\n\ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1583 nominal alternate\n\ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1584 ------- ---------\n"; |
250 | 1585 |
1586 Fset_buffer (Vstandard_output); | |
1587 | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1588 /* Report on alternates for keys. */ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1589 if (XTYPE (Vkeyboard_translate_table) == Lisp_String) |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1590 { |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1591 int c; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1592 unsigned char *translate = XSTRING (Vkeyboard_translate_table)->data; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1593 int translate_len = XSTRING (Vkeyboard_translate_table)->size; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1594 |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1595 for (c = 0; c < translate_len; c++) |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1596 if (translate[c] != c) |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1597 { |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1598 char buf[20]; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1599 char *bufend; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1600 |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1601 if (alternate_heading) |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1602 { |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1603 insert_string (alternate_heading); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1604 alternate_heading = 0; |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1605 } |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1606 |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1607 bufend = push_key_description (translate[c], buf); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1608 insert (buf, bufend - buf); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1609 Findent_to (make_number (16), make_number (1)); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1610 bufend = push_key_description (c, buf); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1611 insert (buf, bufend - buf); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1612 |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1613 insert ("\n", 1); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1614 } |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1615 |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1616 insert ("\n", 1); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1617 } |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1618 |
465 | 1619 { |
1620 int i, nmaps; | |
1621 Lisp_Object *modes, *maps; | |
1622 | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1623 /* Temporarily switch to descbuf, so that we can get that buffer's |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1624 minor modes correctly. */ |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1625 Fset_buffer (descbuf); |
465 | 1626 nmaps = current_minor_maps (&modes, &maps); |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1627 Fset_buffer (Vstandard_output); |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1628 |
465 | 1629 for (i = 0; i < nmaps; i++) |
1630 { | |
1631 if (XTYPE (modes[i]) == Lisp_Symbol) | |
1632 { | |
1633 insert_char ('`'); | |
1634 insert_string (XSYMBOL (modes[i])->name->data); | |
1635 insert_char ('\''); | |
1636 } | |
1637 else | |
1638 insert_string ("Strangely Named"); | |
1639 insert_string (" Minor Mode Bindings:\n"); | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1640 insert_string (key_heading); |
465 | 1641 describe_map_tree (maps[i], 0, Qnil); |
1642 insert_char ('\n'); | |
1643 } | |
1644 } | |
1645 | |
250 | 1646 start1 = XBUFFER (descbuf)->keymap; |
485 | 1647 if (!NILP (start1)) |
250 | 1648 { |
1649 insert_string ("Local Bindings:\n"); | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1650 insert_string (key_heading); |
465 | 1651 describe_map_tree (start1, 0, Qnil); |
250 | 1652 insert_string ("\n"); |
1653 } | |
1654 | |
1655 insert_string ("Global Bindings:\n"); | |
1120
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1656 if (NILP (start1)) |
0a486e1a45bc
* keymap.c (describe_buffer_bindings): Adjust key_heading to match
Jim Blandy <jimb@redhat.com>
parents:
1095
diff
changeset
|
1657 insert_string (key_heading); |
250 | 1658 |
465 | 1659 describe_map_tree (current_global_map, 0, XBUFFER (descbuf)->keymap); |
250 | 1660 |
1661 Fset_buffer (descbuf); | |
1662 return Qnil; | |
1663 } | |
1664 | |
1665 /* Insert a desription of the key bindings in STARTMAP, | |
1666 followed by those of all maps reachable through STARTMAP. | |
1667 If PARTIAL is nonzero, omit certain "uninteresting" commands | |
1668 (such as `undefined'). | |
1669 If SHADOW is non-nil, it is another map; | |
1670 don't mention keys which would be shadowed by it. */ | |
1671 | |
1672 void | |
1673 describe_map_tree (startmap, partial, shadow) | |
1674 Lisp_Object startmap, shadow; | |
1675 int partial; | |
1676 { | |
1677 register Lisp_Object elt, sh; | |
1678 Lisp_Object maps; | |
1679 struct gcpro gcpro1; | |
1680 | |
1681 maps = Faccessible_keymaps (startmap); | |
1682 GCPRO1 (maps); | |
1683 | |
485 | 1684 for (; !NILP (maps); maps = Fcdr (maps)) |
250 | 1685 { |
1686 elt = Fcar (maps); | |
1687 sh = Fcar (elt); | |
1688 | |
1689 /* If there is no shadow keymap given, don't shadow. */ | |
485 | 1690 if (NILP (shadow)) |
250 | 1691 sh = Qnil; |
1692 | |
1693 /* If the sequence by which we reach this keymap is zero-length, | |
1694 then the shadow map for this keymap is just SHADOW. */ | |
1695 else if ((XTYPE (sh) == Lisp_String | |
1696 && XSTRING (sh)->size == 0) | |
1697 || (XTYPE (sh) == Lisp_Vector | |
1698 && XVECTOR (sh)->size == 0)) | |
1699 sh = shadow; | |
1700 | |
1701 /* If the sequence by which we reach this keymap actually has | |
1702 some elements, then the sequence's definition in SHADOW is | |
1703 what we should use. */ | |
1704 else | |
1705 { | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
1706 sh = Flookup_key (shadow, Fcar (elt), Qt); |
250 | 1707 if (XTYPE (sh) == Lisp_Int) |
1708 sh = Qnil; | |
1709 } | |
1710 | |
1711 /* If sh is null (meaning that the current map is not shadowed), | |
1712 or a keymap (meaning that bindings from the current map might | |
1713 show through), describe the map. Otherwise, sh is a command | |
1714 that completely shadows the current map, and we shouldn't | |
1715 bother. */ | |
485 | 1716 if (NILP (sh) || !NILP (Fkeymapp (sh))) |
250 | 1717 describe_map (Fcdr (elt), Fcar (elt), partial, sh); |
1718 } | |
1719 | |
1720 UNGCPRO; | |
1721 } | |
1722 | |
1723 static void | |
1724 describe_command (definition) | |
1725 Lisp_Object definition; | |
1726 { | |
1727 register Lisp_Object tem1; | |
1728 | |
1729 Findent_to (make_number (16), make_number (1)); | |
1730 | |
1731 if (XTYPE (definition) == Lisp_Symbol) | |
1732 { | |
1733 XSET (tem1, Lisp_String, XSYMBOL (definition)->name); | |
1734 insert1 (tem1); | |
1735 insert_string ("\n"); | |
1736 } | |
1737 else | |
1738 { | |
1739 tem1 = Fkeymapp (definition); | |
485 | 1740 if (!NILP (tem1)) |
250 | 1741 insert_string ("Prefix Command\n"); |
1742 else | |
1743 insert_string ("??\n"); | |
1744 } | |
1745 } | |
1746 | |
1747 /* Describe the contents of map MAP, assuming that this map itself is | |
1748 reached by the sequence of prefix keys KEYS (a string or vector). | |
1749 PARTIAL, SHADOW is as in `describe_map_tree' above. */ | |
1750 | |
1751 static void | |
1752 describe_map (map, keys, partial, shadow) | |
1753 Lisp_Object map, keys; | |
1754 int partial; | |
1755 Lisp_Object shadow; | |
1756 { | |
1757 register Lisp_Object keysdesc; | |
1758 | |
1517
72b7bbcaf7d8
* keymap.c (Fdefine_key, Flookup_key, describe_map): Don't assume
Jim Blandy <jimb@redhat.com>
parents:
1441
diff
changeset
|
1759 if (!NILP (keys) && XFASTINT (Flength (keys)) > 0) |
1890
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1760 { |
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1761 Lisp_Object tem; |
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1762 /* Call Fkey_description first, to avoid GC bug for the other string. */ |
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1763 tem = Fkey_description (keys); |
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1764 keysdesc = concat2 (tem, build_string (" ")); |
0ca7640360bd
(describe_map): Call Fkey_description before build_string.
Richard M. Stallman <rms@gnu.org>
parents:
1871
diff
changeset
|
1765 } |
250 | 1766 else |
1767 keysdesc = Qnil; | |
1768 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1769 describe_map_2 (map, keysdesc, describe_command, partial, shadow); |
250 | 1770 } |
1771 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1772 /* Insert a description of KEYMAP into the current buffer. */ |
250 | 1773 |
1774 static void | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1775 describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1776 register Lisp_Object keymap; |
250 | 1777 Lisp_Object elt_prefix; |
1778 int (*elt_describer) (); | |
1779 int partial; | |
1780 Lisp_Object shadow; | |
1781 { | |
1782 Lisp_Object this; | |
1783 Lisp_Object tem1, tem2 = Qnil; | |
1784 Lisp_Object suppress; | |
1785 Lisp_Object kludge; | |
1786 int first = 1; | |
1787 struct gcpro gcpro1, gcpro2, gcpro3; | |
1788 | |
1789 if (partial) | |
1790 suppress = intern ("suppress-keymap"); | |
1791 | |
1792 /* This vector gets used to present single keys to Flookup_key. Since | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1793 that is done once per keymap element, we don't want to cons up a |
250 | 1794 fresh vector every time. */ |
1795 kludge = Fmake_vector (make_number (1), Qnil); | |
1796 | |
1797 GCPRO3 (elt_prefix, tem2, kludge); | |
1798 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1799 for (; CONSP (keymap); keymap = Fcdr (keymap)) |
250 | 1800 { |
1801 QUIT; | |
1802 | |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1803 if (XTYPE (XCONS (keymap)->car) == Lisp_Vector) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1804 describe_vector (XCONS (keymap)->car, |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1805 elt_prefix, elt_describer, partial, shadow); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1806 else |
250 | 1807 { |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1808 tem1 = Fcar_safe (Fcar (keymap)); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1809 tem2 = get_keyelt (Fcdr_safe (Fcar (keymap))); |
250 | 1810 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1811 /* Don't show undefined commands or suppressed commands. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1812 if (NILP (tem2)) continue; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1813 if (XTYPE (tem2) == Lisp_Symbol && partial) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1814 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1815 this = Fget (tem2, suppress); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1816 if (!NILP (this)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1817 continue; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1818 } |
250 | 1819 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1820 /* Don't show a command that isn't really visible |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1821 because a local definition of the same key shadows it. */ |
250 | 1822 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1823 if (!NILP (shadow)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1824 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1825 Lisp_Object tem; |
250 | 1826 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1827 XVECTOR (kludge)->contents[0] = tem1; |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
1828 tem = Flookup_key (shadow, kludge, Qt); |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1829 if (!NILP (tem)) continue; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1830 } |
250 | 1831 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1832 if (first) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1833 { |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1834 insert ("\n", 1); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1835 first = 0; |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1836 } |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1837 |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1838 if (!NILP (elt_prefix)) |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1839 insert1 (elt_prefix); |
250 | 1840 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1841 /* THIS gets the string to describe the character TEM1. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1842 this = Fsingle_key_description (tem1); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1843 insert1 (this); |
250 | 1844 |
1209
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1845 /* Print a description of the definition of this character. |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1846 elt_describer will take care of spacing out far enough |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1847 for alignment purposes. */ |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1848 (*elt_describer) (tem2); |
1aa2cd425737
* keymap.c (DENSE_TABLE_SIZE): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
1160
diff
changeset
|
1849 } |
250 | 1850 } |
1851 | |
1852 UNGCPRO; | |
1853 } | |
1854 | |
1855 static int | |
1856 describe_vector_princ (elt) | |
1857 Lisp_Object elt; | |
1858 { | |
1859 Fprinc (elt, Qnil); | |
1860 } | |
1861 | |
1862 DEFUN ("describe-vector", Fdescribe_vector, Sdescribe_vector, 1, 1, 0, | |
1863 "Print on `standard-output' a description of contents of VECTOR.\n\ | |
1864 This is text showing the elements of vector matched against indices.") | |
1865 (vector) | |
1866 Lisp_Object vector; | |
1867 { | |
1868 CHECK_VECTOR (vector, 0); | |
1922
648bc44d182a
* keymap.c (Fdescribe_vector): Pass the proper number of arguments
Jim Blandy <jimb@redhat.com>
parents:
1890
diff
changeset
|
1869 describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil); |
250 | 1870 } |
1871 | |
1872 describe_vector (vector, elt_prefix, elt_describer, partial, shadow) | |
1873 register Lisp_Object vector; | |
1874 Lisp_Object elt_prefix; | |
1875 int (*elt_describer) (); | |
1876 int partial; | |
1877 Lisp_Object shadow; | |
1878 { | |
1879 Lisp_Object this; | |
1880 Lisp_Object dummy; | |
1881 Lisp_Object tem1, tem2; | |
1882 register int i; | |
1883 Lisp_Object suppress; | |
1884 Lisp_Object kludge; | |
1885 int first = 1; | |
1886 struct gcpro gcpro1, gcpro2, gcpro3; | |
1887 | |
1888 tem1 = Qnil; | |
1889 | |
1890 /* This vector gets used to present single keys to Flookup_key. Since | |
1891 that is done once per vector element, we don't want to cons up a | |
1892 fresh vector every time. */ | |
1893 kludge = Fmake_vector (make_number (1), Qnil); | |
1894 GCPRO3 (elt_prefix, tem1, kludge); | |
1895 | |
1896 if (partial) | |
1897 suppress = intern ("suppress-keymap"); | |
1898 | |
1899 for (i = 0; i < DENSE_TABLE_SIZE; i++) | |
1900 { | |
1901 QUIT; | |
1902 tem1 = get_keyelt (XVECTOR (vector)->contents[i]); | |
1903 | |
485 | 1904 if (NILP (tem1)) continue; |
250 | 1905 |
1906 /* Don't mention suppressed commands. */ | |
1907 if (XTYPE (tem1) == Lisp_Symbol && partial) | |
1908 { | |
1909 this = Fget (tem1, suppress); | |
485 | 1910 if (!NILP (this)) |
250 | 1911 continue; |
1912 } | |
1913 | |
1914 /* If this command in this map is shadowed by some other map, | |
1915 ignore it. */ | |
485 | 1916 if (!NILP (shadow)) |
250 | 1917 { |
1918 Lisp_Object tem; | |
1919 | |
1920 XVECTOR (kludge)->contents[0] = make_number (i); | |
1871
00bee181f7ed
* keymap.c (Flookup_key, Fkey_binding, Flocal_key_binding,
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
1921 tem = Flookup_key (shadow, kludge, Qt); |
250 | 1922 |
485 | 1923 if (!NILP (tem)) continue; |
250 | 1924 } |
1925 | |
1926 if (first) | |
1927 { | |
1928 insert ("\n", 1); | |
1929 first = 0; | |
1930 } | |
1931 | |
1932 /* Output the prefix that applies to every entry in this map. */ | |
485 | 1933 if (!NILP (elt_prefix)) |
250 | 1934 insert1 (elt_prefix); |
1935 | |
1936 /* Get the string to describe the character I, and print it. */ | |
1937 XFASTINT (dummy) = i; | |
1938 | |
1939 /* THIS gets the string to describe the character DUMMY. */ | |
1940 this = Fsingle_key_description (dummy); | |
1941 insert1 (this); | |
1942 | |
1943 /* Find all consecutive characters that have the same definition. */ | |
1944 while (i + 1 < DENSE_TABLE_SIZE | |
1945 && (tem2 = get_keyelt (XVECTOR (vector)->contents[i+1]), | |
1946 EQ (tem2, tem1))) | |
1947 i++; | |
1948 | |
1949 /* If we have a range of more than one character, | |
1950 print where the range reaches to. */ | |
1951 | |
1952 if (i != XINT (dummy)) | |
1953 { | |
1954 insert (" .. ", 4); | |
485 | 1955 if (!NILP (elt_prefix)) |
250 | 1956 insert1 (elt_prefix); |
1957 | |
1958 XFASTINT (dummy) = i; | |
1959 insert1 (Fsingle_key_description (dummy)); | |
1960 } | |
1961 | |
1962 /* Print a description of the definition of this character. | |
1963 elt_describer will take care of spacing out far enough | |
1964 for alignment purposes. */ | |
1965 (*elt_describer) (tem1); | |
1966 } | |
1967 | |
1968 UNGCPRO; | |
1969 } | |
1970 | |
465 | 1971 /* Apropos - finding all symbols whose names match a regexp. */ |
250 | 1972 Lisp_Object apropos_predicate; |
1973 Lisp_Object apropos_accumulate; | |
1974 | |
1975 static void | |
1976 apropos_accum (symbol, string) | |
1977 Lisp_Object symbol, string; | |
1978 { | |
1979 register Lisp_Object tem; | |
1980 | |
1981 tem = Fstring_match (string, Fsymbol_name (symbol), Qnil); | |
485 | 1982 if (!NILP (tem) && !NILP (apropos_predicate)) |
250 | 1983 tem = call1 (apropos_predicate, symbol); |
485 | 1984 if (!NILP (tem)) |
250 | 1985 apropos_accumulate = Fcons (symbol, apropos_accumulate); |
1986 } | |
1987 | |
1988 DEFUN ("apropos-internal", Fapropos_internal, Sapropos_internal, 1, 2, 0, | |
1989 "Show all symbols whose names contain match for REGEXP.\n\ | |
1990 If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done\n\ | |
1991 for each symbol and a symbol is mentioned only if that returns non-nil.\n\ | |
1992 Return list of symbols found.") | |
1993 (string, pred) | |
1994 Lisp_Object string, pred; | |
1995 { | |
1996 struct gcpro gcpro1, gcpro2; | |
1997 CHECK_STRING (string, 0); | |
1998 apropos_predicate = pred; | |
1999 GCPRO2 (apropos_predicate, apropos_accumulate); | |
2000 apropos_accumulate = Qnil; | |
2001 map_obarray (Vobarray, apropos_accum, string); | |
2002 apropos_accumulate = Fsort (apropos_accumulate, Qstring_lessp); | |
2003 UNGCPRO; | |
2004 return apropos_accumulate; | |
2005 } | |
2006 | |
2007 syms_of_keymap () | |
2008 { | |
2009 Lisp_Object tem; | |
2010 | |
2011 Qkeymap = intern ("keymap"); | |
2012 staticpro (&Qkeymap); | |
2013 | |
2014 /* Initialize the keymaps standardly used. | |
2015 Each one is the value of a Lisp variable, and is also | |
2016 pointed to by a C variable */ | |
2017 | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2018 global_map = Fmake_keymap (Qnil); |
250 | 2019 Fset (intern ("global-map"), global_map); |
2020 | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2021 meta_map = Fmake_keymap (Qnil); |
250 | 2022 Fset (intern ("esc-map"), meta_map); |
2023 Ffset (intern ("ESC-prefix"), meta_map); | |
2024 | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2025 control_x_map = Fmake_keymap (Qnil); |
250 | 2026 Fset (intern ("ctl-x-map"), control_x_map); |
2027 Ffset (intern ("Control-X-prefix"), control_x_map); | |
2028 | |
2029 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map, | |
2030 "Default keymap to use when reading from the minibuffer."); | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2031 Vminibuffer_local_map = Fmake_sparse_keymap (Qnil); |
250 | 2032 |
2033 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map, | |
2034 "Local keymap for the minibuffer when spaces are not allowed."); | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2035 Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil); |
250 | 2036 |
2037 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map, | |
2038 "Local keymap for minibuffer input with completion."); | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2039 Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil); |
250 | 2040 |
2041 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map, | |
2042 "Local keymap for minibuffer input with completion, for exact match."); | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2043 Vminibuffer_local_must_match_map = Fmake_sparse_keymap (Qnil); |
250 | 2044 |
2045 current_global_map = global_map; | |
2046 | |
465 | 2047 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist, |
2048 "Alist of keymaps to use for minor modes.\n\ | |
2049 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\ | |
2050 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\ | |
2051 If two active keymaps bind the same key, the keymap appearing earlier\n\ | |
2052 in the list takes precedence."); | |
2053 Vminor_mode_map_alist = Qnil; | |
2054 | |
517 | 2055 DEFVAR_LISP ("function-key-map", &Vfunction_key_map, |
2056 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\ | |
2057 This allows Emacs to recognize function keys sent from ASCII\n\ | |
2058 terminals at any point in a key sequence.\n\ | |
2059 \n\ | |
2060 The read-key-sequence function replaces subsequences bound by\n\ | |
2061 function-key-map with their bindings. When the current local and global\n\ | |
2062 keymaps have no binding for the current key sequence but\n\ | |
2063 function-key-map binds a suffix of the sequence to a vector,\n\ | |
2064 read-key-sequence replaces the matching suffix with its binding, and\n\ | |
2065 continues with the new sequence.\n\ | |
2066 \n\ | |
2067 For example, suppose function-key-map binds `ESC O P' to [pf1].\n\ | |
2068 Typing `ESC O P' to read-key-sequence would return [pf1]. Typing\n\ | |
2069 `C-x ESC O P' would return [?\C-x pf1]. If [pf1] were a prefix\n\ | |
2070 key, typing `ESC O P x' would return [pf1 x]."); | |
1095
6578f07e9eb8
(Fmake_sparse_keymap, Fmake_keymap): New optional arg. Callers changed.
Richard M. Stallman <rms@gnu.org>
parents:
647
diff
changeset
|
2071 Vfunction_key_map = Fmake_sparse_keymap (Qnil); |
517 | 2072 |
250 | 2073 Qsingle_key_description = intern ("single-key-description"); |
2074 staticpro (&Qsingle_key_description); | |
2075 | |
2076 Qkey_description = intern ("key-description"); | |
2077 staticpro (&Qkey_description); | |
2078 | |
2079 Qkeymapp = intern ("keymapp"); | |
2080 staticpro (&Qkeymapp); | |
2081 | |
2727
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
2082 Qnon_ascii = intern ("non-ascii"); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
2083 staticpro (&Qnon_ascii); |
b8911c8b9700
* keymap.c (Fwhere_is_internal): If FIRSTONLY is non-nil, avoid
Jim Blandy <jimb@redhat.com>
parents:
2652
diff
changeset
|
2084 |
250 | 2085 defsubr (&Skeymapp); |
2086 defsubr (&Smake_keymap); | |
2087 defsubr (&Smake_sparse_keymap); | |
2088 defsubr (&Scopy_keymap); | |
2089 defsubr (&Skey_binding); | |
2090 defsubr (&Slocal_key_binding); | |
2091 defsubr (&Sglobal_key_binding); | |
465 | 2092 defsubr (&Sminor_mode_key_binding); |
250 | 2093 defsubr (&Sglobal_set_key); |
2094 defsubr (&Slocal_set_key); | |
2095 defsubr (&Sdefine_key); | |
2096 defsubr (&Slookup_key); | |
2097 defsubr (&Sglobal_unset_key); | |
2098 defsubr (&Slocal_unset_key); | |
2099 defsubr (&Sdefine_prefix_command); | |
2100 defsubr (&Suse_global_map); | |
2101 defsubr (&Suse_local_map); | |
2102 defsubr (&Scurrent_local_map); | |
2103 defsubr (&Scurrent_global_map); | |
465 | 2104 defsubr (&Scurrent_minor_mode_maps); |
250 | 2105 defsubr (&Saccessible_keymaps); |
2106 defsubr (&Skey_description); | |
2107 defsubr (&Sdescribe_vector); | |
2108 defsubr (&Ssingle_key_description); | |
2109 defsubr (&Stext_char_description); | |
2110 defsubr (&Swhere_is_internal); | |
2111 defsubr (&Swhere_is); | |
2112 defsubr (&Sdescribe_bindings); | |
2113 defsubr (&Sapropos_internal); | |
2114 } | |
2115 | |
2116 keys_of_keymap () | |
2117 { | |
2118 Lisp_Object tem; | |
2119 | |
2120 initial_define_key (global_map, 033, "ESC-prefix"); | |
2121 initial_define_key (global_map, Ctl('X'), "Control-X-prefix"); | |
2122 } |