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