/* 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 Free Software Foundation, Inc.
+ Copyright (C) 1985-1988, 1993-1995, 1998-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "keymap.h"
#include "window.h"
-/* The number of elements in keymap vectors. */
-#define DENSE_TABLE_SIZE (0200)
-
/* Actually allocate storage for these variables */
Lisp_Object current_global_map; /* Current global keymap */
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;
+static Lisp_Object Qkeymapp, Qnon_ascii;
+Lisp_Object Qkeymap, Qmenu_item, Qremap;
+static Lisp_Object QCadvertised_binding;
/* Alist of elements like (DEL . "\d"). */
static Lisp_Object exclude_keys;
/* 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;
+INFUN (Flookup_key, 3);
static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
static void fix_submap_inheritance (Lisp_Object, 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);
+ Lisp_Object, Lisp_Object, 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. */
Fcons (Fmake_char_table (Qkeymap, Qnil), tail));
}
-DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
+DEFUE ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
doc: /* Construct and return a new sparse keymap.
Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
void
-initial_define_key (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 (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));
}
return (KEYMAPP (object) ? Qt : Qnil);
}
-DEFUN ("keymap-prompt", Fkeymap_prompt, Skeymap_prompt, 1, 1, 0,
+DEFUE ("keymap-prompt", Fkeymap_prompt, Skeymap_prompt, 1, 1, 0,
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. */)
If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
is zero as well), return Qt.
- ERROR controls how we respond if OBJECT isn't a keymap.
- If ERROR is non-zero, signal an error; otherwise, just return Qnil.
+ ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
+ If ERROR_IF_NOT_KEYMAP is non-zero, signal an error; otherwise,
+ just return Qnil.
Note that most of the time, we don't want to pursue autoloads.
Functions like Faccessible_keymaps which scan entire keymap trees
do_autoload which can GC. */
Lisp_Object
-get_keymap (Lisp_Object object, int error, int autoload)
+get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
{
Lisp_Object tem;
/* Should we do an autoload? Autoload forms for keymaps have
Qkeymap as their fifth element. */
- if ((autoload || !error) && EQ (XCAR (tem), Qautoload)
+ if ((autoload || !error_if_not_keymap) && EQ (XCAR (tem), Qautoload)
&& SYMBOLP (object))
{
Lisp_Object tail;
}
end:
- if (error)
+ if (error_if_not_keymap)
wrong_type_argument (Qkeymapp, object);
return Qnil;
}
/* Return the parent map of KEYMAP, or nil if it has none.
We assume that KEYMAP is a valid keymap. */
-Lisp_Object
+static Lisp_Object
keymap_parent (Lisp_Object keymap, int autoload)
{
Lisp_Object list;
}
/* Check whether MAP is one of MAPS parents. */
-int
+static int
keymap_memberp (Lisp_Object map, Lisp_Object maps)
{
if (NILP (map)) return 0;
/* Set the parent keymap of MAP to PARENT. */
-DEFUN ("set-keymap-parent", Fset_keymap_parent, Sset_keymap_parent, 2, 2, 0,
+DEFUE ("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. */)
(Lisp_Object keymap, Lisp_Object parent)
/* See if there is a meta-map. If there's none, there is
no binding for IDX, unless a default binding exists in MAP. */
struct gcpro gcpro1;
- Lisp_Object meta_map;
+ Lisp_Object event_meta_map;
GCPRO1 (map);
/* A strange value in which Meta is set would cause
infinite recursion. Protect against that. */
if (XINT (meta_prefix_char) & CHAR_META)
meta_prefix_char = make_number (27);
- meta_map = get_keymap (access_keymap (map, meta_prefix_char,
- t_ok, noinherit, autoload),
- 0, autoload);
+ event_meta_map = get_keymap (access_keymap (map, meta_prefix_char,
+ t_ok, noinherit, autoload),
+ 0, autoload);
UNGCPRO;
- if (CONSP (meta_map))
+ if (CONSP (event_meta_map))
{
- map = meta_map;
+ map = event_meta_map;
idx = make_number (XUINT (idx) & ~meta_modifier);
}
else if (t_ok)
{
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. */
/* Call FUN for every binding in MAP and stop at (and return) the parent.
FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
-Lisp_Object
+static Lisp_Object
map_keymap_internal (Lisp_Object map,
map_keymap_function_t fun,
Lisp_Object args,
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)));
}
UNGCPRO;
}
-Lisp_Object Qkeymap_canonicalize;
+static Lisp_Object Qkeymap_canonicalize;
/* Same as map_keymap, but does it right, properly eliminating duplicate
bindings due to inheritance. */
This can GC because menu_item_eval_property calls Feval. */
-Lisp_Object
+static Lisp_Object
get_keyelt (Lisp_Object object, int autoload)
{
while (1)
return def;
}
-EXFUN (Fcopy_keymap, 1);
+INFUN (Fcopy_keymap, 1);
-Lisp_Object
+static Lisp_Object
copy_keymap_item (Lisp_Object elt)
{
Lisp_Object res, tem;
/* GC is possible in this function if it autoloads a keymap. */
-DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
+DEFUE ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
doc: /* In KEYMAP, define key sequence KEY as DEF.
KEYMAP is a keymap.
int i = ASIZE (def);
while (--i >= 0)
{
- Lisp_Object c = AREF (def, i);
- if (CONSP (c) && lucid_event_type_list_p (c))
- c = Fevent_convert_list (c);
- ASET (tmp, i, c);
+ Lisp_Object defi = AREF (def, i);
+ if (CONSP (defi) && lucid_event_type_list_p (defi))
+ defi = Fevent_convert_list (defi);
+ ASET (tmp, i, defi);
}
def = tmp;
}
&& (!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));
/* This function may GC (it calls Fkey_binding). */
-DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 3, 0,
+DEFUE ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 3, 0,
doc: /* Return the remapping for command COMMAND.
Returns nil if COMMAND is not remapped (or not a symbol).
/* 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)
/* Append a key to the end of a key sequence. We always make a vector. */
-Lisp_Object
+static Lisp_Object
append_key (Lisp_Object key_sequence, Lisp_Object key)
{
Lisp_Object args[2];
return i;
}
-DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps,
+DEFUE ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps,
0, 2, 0,
doc: /* Return a list of the currently active keymaps.
OLP if non-nil indicates that we should obey `overriding-local-map' and
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. */
/* GC is possible in this function if it autoloads a keymap. */
-DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 4, 0,
+DEFUE ("key-binding", Fkey_binding, Skey_binding, 1, 4, 0,
doc: /* Return the binding for command KEY in current keymaps.
KEY is a string or vector, a sequence of keystrokes.
The binding is probably a symbol with a function definition.
}
}
- 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;
(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 (!NILP (keymap))
keymap = get_keymap (keymap, 1, 1);
- current_buffer->keymap = keymap;
+ BVAR (current_buffer, keymap) = keymap;
return Qnil;
}
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,
}
return maps;
}
-Lisp_Object Qsingle_key_description, Qkey_description;
+static Lisp_Object Qsingle_key_description, Qkey_description;
/* This function cannot GC. */
-DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
+DEFUE ("key-description", Fkey_description, Skey_description, 1, 2, 0,
doc: /* Return a pretty description of key-sequence KEYS.
Optional arg PREFIX is the sequence of keys leading up to KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo",
*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);
+ *p++ = multibyte_char_to_unibyte (c);
else
p += CHAR_STRING (c, (unsigned char *) p);
}
/* This function cannot GC. */
-DEFUN ("single-key-description", Fsingle_key_description,
+DEFUE ("single-key-description", Fsingle_key_description,
Ssingle_key_description, 1, 2, 0,
doc: /* Return a pretty description of command character KEY.
Control characters turn into C-whatever, etc.
return Qnil;
}
-char *
+static char *
push_text_char_description (register unsigned int c, register char *p)
{
if (c >= 0200)
(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);
}
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,
+DEFUE ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
doc: /* Return list of keys that invoke DEFINITION.
If KEYMAP is a keymap, search only KEYMAP and the global keymap.
If KEYMAP is nil, search all the currently active keymaps.
&& !NILP (firstonly)
&& !NILP (tem = Fget (definition, QCadvertised_binding)))
{
- /* We have a list of advertized bindings. */
+ /* We have a list of advertised bindings. */
while (CONSP (tem))
if (EQ (shadow_lookup (keymaps, XCAR (tem), Qnil, 0), definition))
return XCAR (tem);
considered remapped sequences yet, copy them over and
process them. */
|| (!remapped && (sequences = remapped_sequences,
- remapped = 1),
- CONSP (sequences)))
+ remapped = 1,
+ CONSP (sequences))))
{
Lisp_Object sequence, function;
seems to be only one menu item to report. */
if (! NILP (sequence))
{
- Lisp_Object tem;
- tem = Faref (sequence, make_number (ASIZE (sequence) - 1));
- if (STRINGP (tem))
+ Lisp_Object tem1;
+ tem1 = Faref (sequence, make_number (ASIZE (sequence) - 1));
+ if (STRINGP (tem1))
Faset (sequence, make_number (ASIZE (sequence) - 1),
build_string ("(any string)"));
}
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;
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;
void
describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
- Lisp_Object prefix, char *title, int nomenu, int transl,
+ 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";
/* Delete from MAPS each element that is for the menu bar. */
for (list = maps; CONSP (list); list = XCDR (list))
{
- Lisp_Object elt, prefix, tem;
+ Lisp_Object elt, elt_prefix, tem;
elt = XCAR (list);
- prefix = Fcar (elt);
- if (XVECTOR (prefix)->size >= 1)
+ elt_prefix = Fcar (elt);
+ if (XVECTOR (elt_prefix)->size >= 1)
{
- tem = Faref (prefix, make_number (0));
+ tem = Faref (elt_prefix, make_number (0));
if (EQ (tem, Qmenu_bar))
maps = Fdelq (elt, maps);
}
for (; CONSP (maps); maps = XCDR (maps))
{
- register Lisp_Object elt, prefix, tail;
+ register Lisp_Object elt, elt_prefix, tail;
elt = XCAR (maps);
- prefix = Fcar (elt);
+ elt_prefix = Fcar (elt);
sub_shadows = Qnil;
/* If the sequence by which we reach this keymap is zero-length,
then the shadow map for this keymap is just SHADOW. */
- if ((STRINGP (prefix) && SCHARS (prefix) == 0)
- || (VECTORP (prefix) && XVECTOR (prefix)->size == 0))
+ if ((STRINGP (elt_prefix) && SCHARS (elt_prefix) == 0)
+ || (VECTORP (elt_prefix) && XVECTOR (elt_prefix)->size == 0))
;
/* If the sequence by which we reach this keymap actually has
some elements, then the sequence's definition in SHADOW is
for (tail = orig_maps; !EQ (tail, maps); tail = XCDR (tail))
{
Lisp_Object tem;
- tem = Fequal (Fcar (XCAR (tail)), prefix);
+ tem = Fequal (Fcar (XCAR (tail)), elt_prefix);
if (!NILP (tem))
sub_shadows = Fcons (XCDR (XCAR (tail)), sub_shadows);
}
- describe_map (Fcdr (elt), prefix,
+ describe_map (Fcdr (elt), elt_prefix,
transl ? describe_translation : describe_command,
partial, sub_shadows, &seen, nomenu, mention_shadow);
describe_command (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
- int column = (int) current_column (); /* iftc */
+ EMACS_INT column = current_column ();
int description_column;
/* If column 16 is no good, go to col 32;
|| CHAR_TABLE_P (XCAR (tail)))
describe_vector (XCAR (tail),
prefix, Qnil, elt_describer, partial, shadow, map,
- (int *)0, 0, 1, mention_shadow);
+ 1, mention_shadow);
else if (CONSP (XCAR (tail)))
{
int this_shadowed = 0;
specbind (Qstandard_output, Fcurrent_buffer ());
CHECK_VECTOR_OR_CHAR_TABLE (vector);
describe_vector (vector, Qnil, describer, describe_vector_princ, 0,
- Qnil, Qnil, (int *)0, 0, 0, 0);
+ Qnil, Qnil, 0, 0);
return unbind_to (count, Qnil);
}
ARGS is simply passed as the second argument to ELT_DESCRIBER.
- INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
- the near future.
-
KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
ARGS is simply passed as the second argument to ELT_DESCRIBER. */
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)
+ int keymap_p, int mention_shadow)
{
Lisp_Object definition;
Lisp_Object tem2;
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,
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) */
HCoop / bpt / emacs.git / blobdiff