/* Manipulation of keymaps
- Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1985-1988, 1993-1995, 1998-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
#include <setjmp.h>
-#if HAVE_ALLOCA_H
-# include <alloca.h>
-#endif
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
Lisp_Object control_x_map; /* The keymap used for globally bound
C-x-prefixed default commands */
-/* was MinibufLocalMap */
-Lisp_Object Vminibuffer_local_map;
/* The keymap used by the minibuf for local
bindings when spaces are allowed in the
minibuf */
-/* was MinibufLocalNSMap */
-Lisp_Object Vminibuffer_local_ns_map;
/* The keymap used by the minibuf for local
bindings when spaces are not encouraged
in the minibuf */
/* keymap used for minibuffers when doing completion */
-/* was MinibufLocalCompletionMap */
-Lisp_Object Vminibuffer_local_completion_map;
-
-/* keymap used for minibuffers when doing completion in filenames */
-Lisp_Object Vminibuffer_local_filename_completion_map;
-
-/* keymap used for minibuffers when doing completion in filenames
- with require-match*/
-Lisp_Object Vminibuffer_local_filename_must_match_map;
-
/* keymap used for minibuffers when doing completion and require a match */
-/* was MinibufLocalMustMatchMap */
-Lisp_Object Vminibuffer_local_must_match_map;
-
-/* Alist of minor mode variables and keymaps. */
-Lisp_Object Vminor_mode_map_alist;
-
-/* Alist of major-mode-specific overrides for
- minor mode variables and keymaps. */
-Lisp_Object Vminor_mode_overriding_map_alist;
-
-/* List of emulation mode keymap alists. */
-Lisp_Object Vemulation_mode_map_alists;
-
-/* A list of all commands given new bindings since a certain time
- when nil was stored here.
- This is used to speed up recomputation of menu key equivalents
- when Emacs starts up. t means don't record anything here. */
-Lisp_Object Vdefine_key_rebound_commands;
-
Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii, Qmenu_item, Qremap;
Lisp_Object QCadvertised_binding;
/* Pre-allocated 2-element vector for Fcommand_remapping to use. */
static Lisp_Object command_remapping_vector;
-/* A char with the CHAR_META bit set in a vector or the 0200 bit set
- in a string key sequence is equivalent to prefixing with this
- character. */
-extern Lisp_Object meta_prefix_char;
-
-extern Lisp_Object Voverriding_local_map;
-
/* Hash table used to cache a reverse-map to speed up calls to where-is. */
static Lisp_Object where_is_cache;
/* Which keymaps are reverse-stored in the cache. */
static Lisp_Object where_is_cache_keymaps;
-static Lisp_Object store_in_keymap P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
-static void fix_submap_inheritance P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
-
-static Lisp_Object define_as_prefix P_ ((Lisp_Object, Lisp_Object));
-static void describe_command P_ ((Lisp_Object, Lisp_Object));
-static void describe_translation P_ ((Lisp_Object, Lisp_Object));
-static void describe_map P_ ((Lisp_Object, Lisp_Object,
- void (*) P_ ((Lisp_Object, Lisp_Object)),
- int, Lisp_Object, Lisp_Object*, int, int));
-static void describe_vector P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
- void (*) (Lisp_Object, Lisp_Object), int,
- Lisp_Object, Lisp_Object, int *,
- int, int, int));
-static void silly_event_symbol_error P_ ((Lisp_Object));
+static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
+static void fix_submap_inheritance (Lisp_Object, Lisp_Object, Lisp_Object);
+
+static Lisp_Object define_as_prefix (Lisp_Object, Lisp_Object);
+static void describe_command (Lisp_Object, Lisp_Object);
+static void describe_translation (Lisp_Object, Lisp_Object);
+static void describe_map (Lisp_Object, Lisp_Object,
+ void (*) (Lisp_Object, Lisp_Object),
+ int, Lisp_Object, Lisp_Object*, int, int);
+static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
+ void (*) (Lisp_Object, Lisp_Object), int,
+ Lisp_Object, Lisp_Object, int *,
+ int, int, int);
+static void silly_event_symbol_error (Lisp_Object);
+static Lisp_Object get_keyelt (Lisp_Object, int);
\f
/* Keymap object support - constructors and predicates. */
The optional arg STRING supplies a menu name for the keymap
in case you use it as a menu with `x-popup-menu'. */)
- (string)
- Lisp_Object string;
+ (Lisp_Object string)
{
Lisp_Object tail;
if (!NILP (string))
The optional arg STRING supplies a menu name for the keymap
in case you use it as a menu with `x-popup-menu'. */)
- (string)
- Lisp_Object string;
+ (Lisp_Object string)
{
if (!NILP (string))
{
initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
void
-initial_define_key (keymap, key, defname)
- Lisp_Object keymap;
- int key;
- char *defname;
+initial_define_key (Lisp_Object keymap, int key, const char *defname)
{
store_in_keymap (keymap, make_number (key), intern_c_string (defname));
}
void
-initial_define_lispy_key (keymap, keyname, defname)
- Lisp_Object keymap;
- char *keyname;
- char *defname;
+initial_define_lispy_key (Lisp_Object keymap, const char *keyname, const char *defname)
{
store_in_keymap (keymap, intern_c_string (keyname), intern_c_string (defname));
}
ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
a vector of densely packed bindings for small character codes
is also allowed as an element. */)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
return (KEYMAPP (object) ? Qt : Qnil);
}
doc: /* Return the prompt-string of a keymap MAP.
If non-nil, the prompt is shown in the echo-area
when reading a key-sequence to be looked-up in this keymap. */)
- (map)
- Lisp_Object map;
+ (Lisp_Object map)
{
map = get_keymap (map, 0, 0);
while (CONSP (map))
do_autoload which can GC. */
Lisp_Object
-get_keymap (object, error, autoload)
- Lisp_Object object;
- int error, autoload;
+get_keymap (Lisp_Object object, int error, int autoload)
{
Lisp_Object tem;
We assume that KEYMAP is a valid keymap. */
Lisp_Object
-keymap_parent (keymap, autoload)
- Lisp_Object keymap;
- int autoload;
+keymap_parent (Lisp_Object keymap, int autoload)
{
Lisp_Object list;
DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
doc: /* Return the parent keymap of KEYMAP.
If KEYMAP has no parent, return nil. */)
- (keymap)
- Lisp_Object keymap;
+ (Lisp_Object keymap)
{
return keymap_parent (keymap, 1);
}
/* Check whether MAP is one of MAPS parents. */
int
-keymap_memberp (map, maps)
- Lisp_Object map, maps;
+keymap_memberp (Lisp_Object map, Lisp_Object maps)
{
if (NILP (map)) return 0;
while (KEYMAPP (maps) && !EQ (map, maps))
DEFUN ("set-keymap-parent", Fset_keymap_parent, Sset_keymap_parent, 2, 2, 0,
doc: /* Modify KEYMAP to set its parent map to PARENT.
Return PARENT. PARENT should be nil or another keymap. */)
- (keymap, parent)
- Lisp_Object keymap, parent;
+ (Lisp_Object keymap, Lisp_Object parent)
{
Lisp_Object list, prev;
struct gcpro gcpro1, gcpro2;
make sure that SUBMAP inherits that definition as its own parent. */
static void
-fix_submap_inheritance (map, event, submap)
- Lisp_Object map, event, submap;
+fix_submap_inheritance (Lisp_Object map, Lisp_Object event, Lisp_Object submap)
{
Lisp_Object map_parent, parent_entry;
If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
Lisp_Object
-access_keymap (map, idx, t_ok, noinherit, autoload)
- Lisp_Object map;
- Lisp_Object idx;
- int t_ok;
- int noinherit;
- int autoload;
+access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
{
Lisp_Object val;
}
static void
-map_keymap_item (fun, args, key, val, data)
- map_keymap_function_t fun;
- Lisp_Object args, key, val;
- void *data;
+map_keymap_item (map_keymap_function_t fun, Lisp_Object args, Lisp_Object key, Lisp_Object val, void *data)
{
/* We should maybe try to detect bindings shadowed by previous
ones and things like that. */
}
static void
-map_keymap_char_table_item (args, key, val)
- Lisp_Object args, key, val;
+map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
{
if (!NILP (val))
{
- map_keymap_function_t fun = XSAVE_VALUE (XCAR (args))->pointer;
+ map_keymap_function_t fun =
+ (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
args = XCDR (args);
/* If the key is a range, make a copy since map_char_table modifies
it in place. */
else if (CHAR_TABLE_P (binding))
{
map_char_table (map_keymap_char_table_item, Qnil, binding,
- Fcons (make_save_value (fun, 0),
+ Fcons (make_save_value ((void *) fun, 0),
Fcons (make_save_value (data, 0),
args)));
}
}
static void
-map_keymap_call (key, val, fun, dummy)
- Lisp_Object key, val, fun;
- void *dummy;
+map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
{
call2 (fun, key, val);
}
/* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
void
-map_keymap (map, fun, args, data, autoload)
- map_keymap_function_t fun;
- Lisp_Object map, args;
- void *data;
- int autoload;
+map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
{
struct gcpro gcpro1;
GCPRO1 (args);
/* Same as map_keymap, but does it right, properly eliminating duplicate
bindings due to inheritance. */
void
-map_keymap_canonical (map, fun, args, data)
- map_keymap_function_t fun;
- Lisp_Object map, args;
- void *data;
+map_keymap_canonical (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data)
{
struct gcpro gcpro1;
GCPRO1 (args);
FUNCTION is called with two arguments: the event that is bound, and
the definition it is bound to. The event may be a character range.
If KEYMAP has a parent, this function returns it without processing it. */)
- (function, keymap)
- Lisp_Object function, keymap;
+ (Lisp_Object function, Lisp_Object keymap)
{
struct gcpro gcpro1;
GCPRO1 (function);
This works recursively: if the parent has itself a parent, then the
grandparent's bindings are also included and so on.
usage: (map-keymap FUNCTION KEYMAP) */)
- (function, keymap, sort_first)
- Lisp_Object function, keymap, sort_first;
+ (Lisp_Object function, Lisp_Object keymap, Lisp_Object sort_first)
{
if (! NILP (sort_first))
return call2 (intern ("map-keymap-sorted"), function, keymap);
This can GC because menu_item_eval_property calls Feval. */
-Lisp_Object
-get_keyelt (object, autoload)
- Lisp_Object object;
- int autoload;
+static Lisp_Object
+get_keyelt (Lisp_Object object, int autoload)
{
while (1)
{
}
static Lisp_Object
-store_in_keymap (keymap, idx, def)
- Lisp_Object keymap;
- register Lisp_Object idx;
- Lisp_Object def;
+store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
{
/* Flush any reverse-map cache. */
where_is_cache = Qnil;
EXFUN (Fcopy_keymap, 1);
Lisp_Object
-copy_keymap_item (elt)
- Lisp_Object elt;
+copy_keymap_item (Lisp_Object elt)
{
Lisp_Object res, tem;
}
static void
-copy_keymap_1 (chartable, idx, elt)
- Lisp_Object chartable, idx, elt;
+copy_keymap_1 (Lisp_Object chartable, Lisp_Object idx, Lisp_Object elt)
{
Fset_char_table_range (chartable, idx, copy_keymap_item (elt));
}
Any key definitions that are subkeymaps are recursively copied.
However, a key definition which is a symbol whose definition is a keymap
is not copied. */)
- (keymap)
- Lisp_Object keymap;
+ (Lisp_Object keymap)
{
register Lisp_Object copy, tail;
keymap = get_keymap (keymap, 1, 0);
sequence of keystrokes and events. Non-ASCII characters with codes
above 127 (such as ISO Latin-1) can be represented by vectors.
Two types of vector have special meanings:
- [remap COMMAND] remaps any key binding for COMMAND in KEYMAP.
+ [remap COMMAND] remaps any key binding for COMMAND.
[t] creates a default definition, which applies to any event with no
other definition in KEYMAP.
If KEYMAP is a sparse keymap with a binding for KEY, the existing
binding is altered. If there is no binding for KEY, the new pair
binding KEY to DEF is added at the front of KEYMAP. */)
- (keymap, key, def)
- Lisp_Object keymap;
- Lisp_Object key;
- Lisp_Object def;
+ (Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
{
register int idx;
register Lisp_Object c;
&& (!CONSP (c)
/* If C is a range, it must be a leaf. */
|| (INTEGERP (XCAR (c)) && idx != length)))
- error ("Key sequence contains invalid event");
+ message_with_string ("Key sequence contains invalid event %s", c, 1);
if (idx == length)
RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
If the optional argument KEYMAPS is non-nil, it should be a list of
keymaps to search for command remapping. Otherwise, search for the
remapping in all currently active keymaps. */)
- (command, position, keymaps)
- Lisp_Object command, position, keymaps;
+ (Lisp_Object command, Lisp_Object position, Lisp_Object keymaps)
{
if (!SYMBOLP (command))
return Qnil;
usable as a general function for probing keymaps. However, if the
third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
recognize the default bindings, just as `read-key-sequence' does. */)
- (keymap, key, accept_default)
- Lisp_Object keymap;
- Lisp_Object key;
- Lisp_Object accept_default;
+ (Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
{
register int idx;
register Lisp_Object cmd;
/* Allow string since binding for `menu-bar-select-buffer'
includes the buffer name in the key sequence. */
if (!INTEGERP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
- error ("Key sequence contains invalid event");
+ message_with_string ("Key sequence contains invalid event %s", c, 1);
cmd = access_keymap (keymap, c, t_ok, 0, 1);
if (idx == length)
Return the keymap. */
static Lisp_Object
-define_as_prefix (keymap, c)
- Lisp_Object keymap, c;
+define_as_prefix (Lisp_Object keymap, Lisp_Object c)
{
Lisp_Object cmd;
/* Append a key to the end of a key sequence. We always make a vector. */
Lisp_Object
-append_key (key_sequence, key)
- Lisp_Object key_sequence, key;
+append_key (Lisp_Object key_sequence, Lisp_Object key)
{
Lisp_Object args[2];
signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
static void
-silly_event_symbol_error (c)
- Lisp_Object c;
+silly_event_symbol_error (Lisp_Object c)
{
Lisp_Object parsed, base, name, assoc;
int modifiers;
list, let the key sequence be read, and hope some other piece of
code signals the error. */
int
-current_minor_maps (modeptr, mapptr)
- Lisp_Object **modeptr, **mapptr;
+current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
{
int i = 0;
int list_number = 0;
{
if (cmm_modes)
{
- bcopy (cmm_modes, newmodes, cmm_size * sizeof cmm_modes[0]);
+ memcpy (newmodes, cmm_modes,
+ cmm_size * sizeof cmm_modes[0]);
free (cmm_modes);
}
cmm_modes = newmodes;
{
if (cmm_maps)
{
- bcopy (cmm_maps, newmaps, cmm_size * sizeof cmm_maps[0]);
+ memcpy (newmaps, cmm_maps,
+ cmm_size * sizeof cmm_maps[0]);
free (cmm_maps);
}
cmm_maps = newmaps;
OLP if non-nil indicates that we should obey `overriding-local-map' and
`overriding-terminal-local-map'. POSITION can specify a click position
like in the respective argument of `key-binding'. */)
- (olp, position)
- Lisp_Object olp, position;
+ (Lisp_Object olp, Lisp_Object position)
{
int count = SPECPDL_INDEX ();
if (!NILP (olp))
{
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- keymaps = Fcons (current_kboard->Voverriding_terminal_local_map, keymaps);
+ if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
+ keymaps = Fcons (KVAR (current_kboard, Voverriding_terminal_local_map), keymaps);
/* The doc said that overriding-terminal-local-map should
override overriding-local-map. The code used them both,
but it seems clearer to use just one. rms, jan 2005. */
be a number or marker, in which case the keymap properties at the
specified buffer position instead of point are used.
*/)
- (key, accept_default, no_remap, position)
- Lisp_Object key, accept_default, no_remap, position;
+ (Lisp_Object key, Lisp_Object accept_default, Lisp_Object no_remap, Lisp_Object position)
{
Lisp_Object *maps, value;
int nmaps, i;
}
}
- if (! NILP (current_kboard->Voverriding_terminal_local_map))
+ if (! NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
{
- value = Flookup_key (current_kboard->Voverriding_terminal_local_map,
+ value = Flookup_key (KVAR (current_kboard, Voverriding_terminal_local_map),
key, accept_default);
if (! NILP (value) && !INTEGERP (value))
goto done;
If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this. */)
- (keys, accept_default)
- Lisp_Object keys, accept_default;
+ (Lisp_Object keys, Lisp_Object accept_default)
{
register Lisp_Object map;
- map = current_buffer->keymap;
+ map = BVAR (current_buffer, keymap);
if (NILP (map))
return Qnil;
return Flookup_key (map, keys, accept_default);
If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this. */)
- (keys, accept_default)
- Lisp_Object keys, accept_default;
+ (Lisp_Object keys, Lisp_Object accept_default)
{
return Flookup_key (current_global_map, keys, accept_default);
}
If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this. */)
- (key, accept_default)
- Lisp_Object key, accept_default;
+ (Lisp_Object key, Lisp_Object accept_default)
{
Lisp_Object *modes, *maps;
int nmaps;
The third optional argument NAME, if given, supplies a menu name
string for the map. This is required to use the keymap as a menu.
This function returns COMMAND. */)
- (command, mapvar, name)
- Lisp_Object command, mapvar, name;
+ (Lisp_Object command, Lisp_Object mapvar, Lisp_Object name)
{
Lisp_Object map;
map = Fmake_sparse_keymap (name);
DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0,
doc: /* Select KEYMAP as the global keymap. */)
- (keymap)
- Lisp_Object keymap;
+ (Lisp_Object keymap)
{
keymap = get_keymap (keymap, 1, 1);
current_global_map = keymap;
DEFUN ("use-local-map", Fuse_local_map, Suse_local_map, 1, 1, 0,
doc: /* Select KEYMAP as the local keymap.
If KEYMAP is nil, that means no local keymap. */)
- (keymap)
- Lisp_Object keymap;
+ (Lisp_Object keymap)
{
if (!NILP (keymap))
keymap = get_keymap (keymap, 1, 1);
- current_buffer->keymap = keymap;
+ BVAR (current_buffer, keymap) = keymap;
return Qnil;
}
DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 0, 0,
doc: /* Return current buffer's local keymap, or nil if it has none.
Normally the local keymap is set by the major mode with `use-local-map'. */)
- ()
+ (void)
{
- return current_buffer->keymap;
+ return BVAR (current_buffer, keymap);
}
DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0,
doc: /* Return the current global keymap. */)
- ()
+ (void)
{
return current_global_map;
}
DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_maps, 0, 0, 0,
doc: /* Return a list of keymaps for the minor modes of the current buffer. */)
- ()
+ (void)
{
Lisp_Object *maps;
int nmaps = current_minor_maps (0, &maps);
};
static void
-accessible_keymaps_1 (key, cmd, args, data)
- Lisp_Object key, cmd, args;
- /* Use void* to be compatible with map_keymap_function_t. */
- void *data;
+accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *data)
+/* Use void* data to be compatible with map_keymap_function_t. */
{
struct accessible_keymaps_data *d = data; /* Cast! */
Lisp_Object maps = d->maps;
so that the KEYS increase in length. The first element is ([] . KEYMAP).
An optional argument PREFIX, if non-nil, should be a key sequence;
then the value includes only maps for prefixes that start with PREFIX. */)
- (keymap, prefix)
- Lisp_Object keymap, prefix;
+ (Lisp_Object keymap, Lisp_Object prefix)
{
Lisp_Object maps, tail;
int prefixlen = XINT (Flength (prefix));
Optional arg PREFIX is the sequence of keys leading up to KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo",
spaces are put between sequence elements, etc. */)
- (keys, prefix)
- Lisp_Object keys, prefix;
+ (Lisp_Object keys, Lisp_Object prefix)
{
int len = 0;
int i, i_byte;
char *
-push_key_description (c, p, force_multibyte)
- register unsigned int c;
- register char *p;
- int force_multibyte;
+push_key_description (register unsigned int c, register char *p, int force_multibyte)
{
unsigned c2;
*p++ = 'C';
}
else if (c < 128
- || (NILP (current_buffer->enable_multibyte_characters)
+ || (NILP (BVAR (current_buffer, enable_multibyte_characters))
&& SINGLE_BYTE_CHAR_P (c)
&& !force_multibyte))
{
else
{
/* Now we are sure that C is a valid character code. */
- if (NILP (current_buffer->enable_multibyte_characters)
+ if (NILP (BVAR (current_buffer, enable_multibyte_characters))
&& ! force_multibyte)
*p++ = multibyte_char_to_unibyte (c, Qnil);
else
Control characters turn into C-whatever, etc.
Optional argument NO-ANGLES non-nil means don't put angle brackets
around function keys and event symbols. */)
- (key, no_angles)
- Lisp_Object key, no_angles;
+ (Lisp_Object key, Lisp_Object no_angles)
{
if (CONSP (key) && lucid_event_type_list_p (key))
key = Fevent_convert_list (key);
}
char *
-push_text_char_description (c, p)
- register unsigned int c;
- register char *p;
+push_text_char_description (register unsigned int c, register char *p)
{
if (c >= 0200)
{
Also, this function recognizes the 2**7 bit as the Meta character,
whereas `single-key-description' uses the 2**27 bit for Meta.
See Info node `(elisp)Describing Characters' for examples. */)
- (character)
- Lisp_Object character;
+ (Lisp_Object character)
{
/* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
- unsigned char str[6];
+ char str[6];
int c;
CHECK_NUMBER (character);
c = XINT (character);
if (!ASCII_CHAR_P (c))
{
- int len = CHAR_STRING (c, str);
+ int len = CHAR_STRING (c, (unsigned char *) str);
return make_multibyte_string (str, 1, len);
}
Else, return 2 if SEQ uses the where_is_preferred_modifier,
and 1 otherwise. */
static int
-preferred_sequence_p (seq)
- Lisp_Object seq;
+preferred_sequence_p (Lisp_Object seq)
{
int i;
int len = XINT (Flength (seq));
\f
/* where-is - finding a command in a set of keymaps. */
-static void where_is_internal_1 P_ ((Lisp_Object key, Lisp_Object binding,
- Lisp_Object args, void *data));
+static void where_is_internal_1 (Lisp_Object key, Lisp_Object binding,
+ Lisp_Object args, void *data);
/* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
Returns the first non-nil binding found in any of those maps.
return data.sequences;
}
-static Lisp_Object Vwhere_is_preferred_modifier;
-
/* This function can GC if Flookup_key autoloads any keymaps. */
DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
that invoke a command which is remapped to DEFINITION, but include the
remapped command in the returned list. */)
- (definition, keymap, firstonly, noindirect, no_remap)
- Lisp_Object definition, keymap;
- Lisp_Object firstonly, noindirect, no_remap;
+ (Lisp_Object definition, Lisp_Object keymap, Lisp_Object firstonly, Lisp_Object noindirect, Lisp_Object no_remap)
{
/* The keymaps in which to search. */
Lisp_Object keymaps;
/* This function can GC because get_keyelt can. */
static void
-where_is_internal_1 (key, binding, args, data)
- Lisp_Object key, binding, args;
- void *data;
+where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, void *data)
{
struct where_is_internal_data *d = data; /* Cast! */
Lisp_Object definition = d->definition;
then we display only bindings that start with that prefix.
The optional argument MENUS, if non-nil, says to mention menu bindings.
\(Ordinarily these are omitted from the output.) */)
- (buffer, prefix, menus)
- Lisp_Object buffer, prefix, menus;
+ (Lisp_Object buffer, Lisp_Object prefix, Lisp_Object menus)
{
Lisp_Object outbuf, shadow;
int nomenu = NILP (menus);
register Lisp_Object start1;
struct gcpro gcpro1;
- char *alternate_heading
+ const char *alternate_heading
= "\
Keyboard translations:\n\n\
You type Translation\n\
outbuf = Fcurrent_buffer ();
/* Report on alternates for keys. */
- if (STRINGP (current_kboard->Vkeyboard_translate_table) && !NILP (prefix))
+ if (STRINGP (KVAR (current_kboard, Vkeyboard_translate_table)) && !NILP (prefix))
{
int c;
- const unsigned char *translate = SDATA (current_kboard->Vkeyboard_translate_table);
- int translate_len = SCHARS (current_kboard->Vkeyboard_translate_table);
+ const unsigned char *translate = SDATA (KVAR (current_kboard, Vkeyboard_translate_table));
+ int translate_len = SCHARS (KVAR (current_kboard, Vkeyboard_translate_table));
for (c = 0; c < translate_len; c++)
if (translate[c] != c)
insert ("\n", 1);
/* Insert calls signal_after_change which may GC. */
- translate = SDATA (current_kboard->Vkeyboard_translate_table);
+ translate = SDATA (KVAR (current_kboard, Vkeyboard_translate_table));
}
insert ("\n", 1);
/* Print the (major mode) local map. */
start1 = Qnil;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- start1 = current_kboard->Voverriding_terminal_local_map;
+ if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
+ start1 = KVAR (current_kboard, Voverriding_terminal_local_map);
else if (!NILP (Voverriding_local_map))
start1 = Voverriding_local_map;
*p++ = '\f';
*p++ = '\n';
*p++ = '`';
- bcopy (SDATA (SYMBOL_NAME (modes[i])), p,
- SCHARS (SYMBOL_NAME (modes[i])));
+ memcpy (p, SDATA (SYMBOL_NAME (modes[i])),
+ SCHARS (SYMBOL_NAME (modes[i])));
p += SCHARS (SYMBOL_NAME (modes[i]));
*p++ = '\'';
- bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings") - 1);
- p += sizeof (" Minor Mode Bindings") - 1;
+ memcpy (p, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
+ p += strlen (" Minor Mode Bindings");
*p = 0;
describe_map_tree (maps[i], 1, shadow, prefix,
XBUFFER (buffer), Qlocal_map);
if (!NILP (start1))
{
- if (EQ (start1, XBUFFER (buffer)->keymap))
+ if (EQ (start1, BVAR (XBUFFER (buffer), keymap)))
describe_map_tree (start1, 1, shadow, prefix,
"\f\nMajor Mode Bindings", nomenu, 0, 0, 0);
else
"\f\nGlobal Bindings", nomenu, 0, 1, 0);
/* Print the function-key-map translations under this prefix. */
- if (!NILP (current_kboard->Vlocal_function_key_map))
- describe_map_tree (current_kboard->Vlocal_function_key_map, 0, Qnil, prefix,
+ if (!NILP (KVAR (current_kboard, Vlocal_function_key_map)))
+ describe_map_tree (KVAR (current_kboard, Vlocal_function_key_map), 0, Qnil, prefix,
"\f\nFunction key map translations", nomenu, 1, 0, 0);
/* Print the input-decode-map translations under this prefix. */
- if (!NILP (current_kboard->Vinput_decode_map))
- describe_map_tree (current_kboard->Vinput_decode_map, 0, Qnil, prefix,
+ if (!NILP (KVAR (current_kboard, Vinput_decode_map)))
+ describe_map_tree (KVAR (current_kboard, Vinput_decode_map), 0, Qnil, prefix,
"\f\nInput decoding map translations", nomenu, 1, 0, 0);
UNGCPRO;
don't omit it; instead, mention it but say it is shadowed. */
void
-describe_map_tree (startmap, partial, shadow, prefix, title, nomenu, transl,
- always_title, mention_shadow)
- Lisp_Object startmap, shadow, prefix;
- int partial;
- char *title;
- int nomenu;
- int transl;
- int always_title;
- int mention_shadow;
+describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
+ Lisp_Object prefix, const char *title, int nomenu, int transl,
+ int always_title, int mention_shadow)
{
Lisp_Object maps, orig_maps, seen, sub_shadows;
struct gcpro gcpro1, gcpro2, gcpro3;
int something = 0;
- char *key_heading
+ const char *key_heading
= "\
key binding\n\
--- -------\n";
static int previous_description_column;
static void
-describe_command (definition, args)
- Lisp_Object definition, args;
+describe_command (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
int column = (int) current_column (); /* iftc */
}
static void
-describe_translation (definition, args)
- Lisp_Object definition, args;
+describe_translation (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
the event field. */
static int
-describe_map_compare (aa, bb)
- const void *aa, *bb;
+describe_map_compare (const void *aa, const void *bb)
{
const struct describe_map_elt *a = aa, *b = bb;
if (INTEGERP (a->event) && INTEGERP (b->event))
PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
static void
-describe_map (map, prefix, elt_describer, partial, shadow,
- seen, nomenu, mention_shadow)
- register Lisp_Object map;
- Lisp_Object prefix;
- void (*elt_describer) P_ ((Lisp_Object, Lisp_Object));
- int partial;
- Lisp_Object shadow;
- Lisp_Object *seen;
- int nomenu;
- int mention_shadow;
+describe_map (Lisp_Object map, Lisp_Object prefix,
+ void (*elt_describer) (Lisp_Object, Lisp_Object),
+ int partial, Lisp_Object shadow,
+ Lisp_Object *seen, int nomenu, int mention_shadow)
{
Lisp_Object tail, definition, event;
Lisp_Object tem;
}
static void
-describe_vector_princ (elt, fun)
- Lisp_Object elt, fun;
+describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
{
Findent_to (make_number (16), make_number (1));
call1 (fun, elt);
doc: /* Insert a description of contents of VECTOR.
This is text showing the elements of vector matched against indices.
DESCRIBER is the output function used; nil means use `princ'. */)
- (vector, describer)
- Lisp_Object vector, describer;
+ (Lisp_Object vector, Lisp_Object describer)
{
int count = SPECPDL_INDEX ();
if (NILP (describer))
ARGS is simply passed as the second argument to ELT_DESCRIBER. */
static void
-describe_vector (vector, prefix, args, elt_describer,
- partial, shadow, entire_map,
- indices, char_table_depth, keymap_p,
- mention_shadow)
- register Lisp_Object vector;
- Lisp_Object prefix, args;
- void (*elt_describer) P_ ((Lisp_Object, Lisp_Object));
- int partial;
- Lisp_Object shadow;
- Lisp_Object entire_map;
- int *indices;
- int char_table_depth;
- int keymap_p;
- int mention_shadow;
+describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
+ void (*elt_describer) (Lisp_Object, Lisp_Object),
+ int partial, Lisp_Object shadow, Lisp_Object entire_map,
+ int *indices, int char_table_depth, int keymap_p,
+ int mention_shadow)
{
Lisp_Object definition;
Lisp_Object tem2;
static Lisp_Object apropos_accumulate;
static void
-apropos_accum (symbol, string)
- Lisp_Object symbol, string;
+apropos_accum (Lisp_Object symbol, Lisp_Object string)
{
register Lisp_Object tem;
If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
for each symbol and a symbol is mentioned only if that returns non-nil.
Return list of symbols found. */)
- (regexp, predicate)
- Lisp_Object regexp, predicate;
+ (Lisp_Object regexp, Lisp_Object predicate)
{
Lisp_Object tem;
CHECK_STRING (regexp);
}
\f
void
-syms_of_keymap ()
+syms_of_keymap (void)
{
Qkeymap = intern_c_string ("keymap");
staticpro (&Qkeymap);
Qnil)))));
staticpro (&exclude_keys);
- DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands,
+ DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands,
doc: /* List of commands given new key bindings recently.
This is used for internal purposes during Emacs startup;
don't alter it yourself. */);
Vdefine_key_rebound_commands = Qt;
- DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map,
+ DEFVAR_LISP ("minibuffer-local-map", Vminibuffer_local_map,
doc: /* Default keymap to use when reading from the minibuffer. */);
Vminibuffer_local_map = Fmake_sparse_keymap (Qnil);
- DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map,
+ DEFVAR_LISP ("minibuffer-local-ns-map", Vminibuffer_local_ns_map,
doc: /* Local keymap for the minibuffer when spaces are not allowed. */);
Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil);
Fset_keymap_parent (Vminibuffer_local_ns_map, Vminibuffer_local_map);
- DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map,
+ DEFVAR_LISP ("minibuffer-local-completion-map", Vminibuffer_local_completion_map,
doc: /* Local keymap for minibuffer input with completion. */);
Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil);
Fset_keymap_parent (Vminibuffer_local_completion_map, Vminibuffer_local_map);
DEFVAR_LISP ("minibuffer-local-filename-completion-map",
- &Vminibuffer_local_filename_completion_map,
+ Vminibuffer_local_filename_completion_map,
doc: /* Local keymap for minibuffer input with completion for filenames. */);
Vminibuffer_local_filename_completion_map = Fmake_sparse_keymap (Qnil);
Fset_keymap_parent (Vminibuffer_local_filename_completion_map,
Vminibuffer_local_completion_map);
- DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map,
+ DEFVAR_LISP ("minibuffer-local-must-match-map", Vminibuffer_local_must_match_map,
doc: /* Local keymap for minibuffer input with completion, for exact match. */);
Vminibuffer_local_must_match_map = Fmake_sparse_keymap (Qnil);
Fset_keymap_parent (Vminibuffer_local_must_match_map,
Vminibuffer_local_completion_map);
DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
- &Vminibuffer_local_filename_must_match_map,
+ Vminibuffer_local_filename_must_match_map,
doc: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
Vminibuffer_local_filename_must_match_map = Fmake_sparse_keymap (Qnil);
Fset_keymap_parent (Vminibuffer_local_filename_must_match_map,
Vminibuffer_local_must_match_map);
- DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist,
+ DEFVAR_LISP ("minor-mode-map-alist", Vminor_mode_map_alist,
doc: /* Alist of keymaps to use for minor modes.
Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
key sequences and look up bindings if VARIABLE's value is non-nil.
in the list takes precedence. */);
Vminor_mode_map_alist = Qnil;
- DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist,
+ DEFVAR_LISP ("minor-mode-overriding-map-alist", Vminor_mode_overriding_map_alist,
doc: /* Alist of keymaps to use for minor modes, in current major mode.
This variable is an alist just like `minor-mode-map-alist', and it is
used the same way (and before `minor-mode-map-alist'); however,
it is provided for major modes to bind locally. */);
Vminor_mode_overriding_map_alist = Qnil;
- DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists,
+ DEFVAR_LISP ("emulation-mode-map-alists", Vemulation_mode_map_alists,
doc: /* List of keymap alists to use for emulations modes.
It is intended for modes or packages using multiple minor-mode keymaps.
Each element is a keymap alist just like `minor-mode-map-alist', or a
`minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
Vemulation_mode_map_alists = Qnil;
- DEFVAR_LISP ("where-is-preferred-modifier", &Vwhere_is_preferred_modifier,
+ DEFVAR_LISP ("where-is-preferred-modifier", Vwhere_is_preferred_modifier,
doc: /* Preferred modifier to use for `where-is'.
When a single binding is requested, `where-is' will return one that
uses this modifier if possible. If nil, or if no such binding exists,
}
void
-keys_of_keymap ()
+keys_of_keymap (void)
{
initial_define_key (global_map, 033, "ESC-prefix");
initial_define_key (global_map, Ctl ('X'), "Control-X-prefix");
}
-
-/* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
- (do not change this comment) */