keymap.c 73.8 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
/* Manipulation of keymaps
Karl Heuer's avatar
Karl Heuer committed
2
   Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
Jim Blandy's avatar
Jim Blandy committed
3 4 5 6 7

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Jim Blandy's avatar
Jim Blandy committed
8
the Free Software Foundation; either version 2, or (at your option)
Jim Blandy's avatar
Jim Blandy committed
9 10 11 12 13 14 15 16 17
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
18 19
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */
Jim Blandy's avatar
Jim Blandy committed
20 21


22
#include <config.h>
Jim Blandy's avatar
Jim Blandy committed
23 24 25 26 27
#include <stdio.h>
#undef NULL
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
Jim Blandy's avatar
Jim Blandy committed
28
#include "keyboard.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
29
#include "termhooks.h"
30
#include "blockinput.h"
31
#include "puresize.h"
Jim Blandy's avatar
Jim Blandy committed
32 33 34

#define min(a, b) ((a) < (b) ? (a) : (b))

35
/* The number of elements in keymap vectors.  */
Jim Blandy's avatar
Jim Blandy committed
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#define DENSE_TABLE_SIZE (0200)

/* Actually allocate storage for these variables */

Lisp_Object current_global_map;	/* Current global keymap */

Lisp_Object global_map;		/* default global key bindings */

Lisp_Object meta_map;		/* The keymap used for globally bound
				   ESC-prefixed default commands */

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 and require a match */
/* was MinibufLocalMustMatchMap */
Lisp_Object Vminibuffer_local_must_match_map;

Jim Blandy's avatar
Jim Blandy committed
70 71 72
/* Alist of minor mode variables and keymaps.  */
Lisp_Object Vminor_mode_map_alist;

Jim Blandy's avatar
Jim Blandy committed
73 74 75 76 77
/* Keymap mapping ASCII function key sequences onto their preferred forms.
   Initialized by the terminal-specific lisp files.  See DEFVAR for more
   documentation.  */
Lisp_Object Vfunction_key_map;

78 79 80
/* Keymap mapping ASCII function key sequences onto their preferred forms.  */
Lisp_Object Vkey_translation_map;

81 82 83 84 85 86
/* 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;

87
Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii;
Jim Blandy's avatar
Jim Blandy committed
88

Jim Blandy's avatar
Jim Blandy committed
89 90 91
/* 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.  */
Jim Blandy's avatar
Jim Blandy committed
92 93
extern Lisp_Object meta_prefix_char;

94 95
extern Lisp_Object Voverriding_local_map;

96
static Lisp_Object define_as_prefix ();
Jim Blandy's avatar
Jim Blandy committed
97
static Lisp_Object describe_buffer_bindings ();
98
static void describe_command (), describe_translation ();
Jim Blandy's avatar
Jim Blandy committed
99 100
static void describe_map ();

Jim Blandy's avatar
Jim Blandy committed
101 102
/* Keymap object support - constructors and predicates.			*/

103
DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,
Jim Blandy's avatar
Jim Blandy committed
104
  "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
105
VECTOR is a vector which holds the bindings for the ASCII\n\
Jim Blandy's avatar
Jim Blandy committed
106 107
characters.  ALIST is an assoc-list which holds bindings for function keys,\n\
mouse events, and any other things that appear in the input stream.\n\
108 109 110 111 112
All entries in it are initially nil, meaning \"command undefined\".\n\n\
The optional arg STRING supplies a menu name for the keymap\n\
in case you use it as a menu with `x-popup-menu'.")
  (string)
     Lisp_Object string;
Jim Blandy's avatar
Jim Blandy committed
113
{
114 115 116 117 118
  Lisp_Object tail;
  if (!NILP (string))
    tail = Fcons (string, Qnil);
  else
    tail = Qnil;
Jim Blandy's avatar
Jim Blandy committed
119 120
  return Fcons (Qkeymap,
		Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE), Qnil),
121
		       tail));
Jim Blandy's avatar
Jim Blandy committed
122 123
}

124
DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
Jim Blandy's avatar
Jim Blandy committed
125 126 127 128
  "Construct and return a new sparse-keymap list.\n\
Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
which binds the function key or mouse event SYMBOL to DEFINITION.\n\
129 130 131 132 133
Initially the alist is nil.\n\n\
The optional arg STRING supplies a menu name for the keymap\n\
in case you use it as a menu with `x-popup-menu'.")
  (string)
     Lisp_Object string;
Jim Blandy's avatar
Jim Blandy committed
134
{
135 136
  if (!NILP (string))
    return Fcons (Qkeymap, Fcons (string, Qnil));
Jim Blandy's avatar
Jim Blandy committed
137 138 139 140 141 142 143 144
  return Fcons (Qkeymap, Qnil);
}

/* This function is used for installing the standard key bindings
   at initialization time.

   For example:

145
   initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark");  */
Jim Blandy's avatar
Jim Blandy committed
146 147 148 149 150 151 152 153 154 155

void
initial_define_key (keymap, key, defname)
     Lisp_Object keymap;
     int key;
     char *defname;
{
  store_in_keymap (keymap, make_number (key), intern (defname));
}

156 157 158 159 160 161 162 163 164
void
initial_define_lispy_key (keymap, keyname, defname)
     Lisp_Object keymap;
     char *keyname;
     char *defname;
{
  store_in_keymap (keymap, intern (keyname), intern (defname));
}

Jim Blandy's avatar
Jim Blandy committed
165 166 167 168 169 170 171 172 173 174 175
/* Define character fromchar in map frommap as an alias for character
   tochar in map tomap.  Subsequent redefinitions of the latter WILL
   affect the former. */

#if 0
void
synkey (frommap, fromchar, tomap, tochar)
     struct Lisp_Vector *frommap, *tomap;
     int fromchar, tochar;
{
  Lisp_Object v, c;
176
  XSETVECTOR (v, tomap);
177
  XSETFASTINT (c, tochar);
Jim Blandy's avatar
Jim Blandy committed
178 179 180 181 182
  frommap->contents[fromchar] = Fcons (v, c);
}
#endif /* 0 */

DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
183
  "Return t if OBJECT is a keymap.\n\
Jim Blandy's avatar
Jim Blandy committed
184
\n\
185
A keymap is a list (keymap . ALIST),\n\
Karl Heuer's avatar
Karl Heuer committed
186
or a symbol whose function definition is itself a keymap.\n\
Jim Blandy's avatar
Jim Blandy committed
187
ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
188 189
a vector of densely packed bindings for small character codes\n\
is also allowed as an element.")
Jim Blandy's avatar
Jim Blandy committed
190 191 192
  (object)
     Lisp_Object object;
{
193
  return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
Jim Blandy's avatar
Jim Blandy committed
194 195 196
}

/* Check that OBJECT is a keymap (after dereferencing through any
197 198 199 200
   symbols).  If it is, return it.

   If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
   is an autoload form, do the autoload and try again.
201
   If AUTOLOAD is nonzero, callers must assume GC is possible.
202 203 204 205 206 207 208 209 210 211

   ERROR controls how we respond if OBJECT isn't a keymap.
   If ERROR is non-zero, signal an error; otherwise, just return Qnil.

   Note that most of the time, we don't want to pursue autoloads.
   Functions like Faccessible_keymaps which scan entire keymap trees
   shouldn't load every autoloaded keymap.  I'm not sure about this,
   but it seems to me that only read_key_sequence, Flookup_key, and
   Fdefine_key should cause keymaps to be autoloaded.  */

Jim Blandy's avatar
Jim Blandy committed
212
Lisp_Object
213
get_keymap_1 (object, error, autoload)
Jim Blandy's avatar
Jim Blandy committed
214
     Lisp_Object object;
215
     int error, autoload;
Jim Blandy's avatar
Jim Blandy committed
216
{
217
  Lisp_Object tem;
Jim Blandy's avatar
Jim Blandy committed
218

219
 autoload_retry:
Jim Blandy's avatar
Jim Blandy committed
220
  tem = indirect_function (object);
Jim Blandy's avatar
Jim Blandy committed
221 222
  if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
    return tem;
223

224 225
  /* Should we do an autoload?  Autoload forms for keymaps have
     Qkeymap as their fifth element.  */
226
  if (autoload
227
      && SYMBOLP (object)
228 229 230
      && CONSP (tem)
      && EQ (XCONS (tem)->car, Qautoload))
    {
231
      Lisp_Object tail;
232

233 234 235 236
      tail = Fnth (make_number (4), tem);
      if (EQ (tail, Qkeymap))
	{
	  struct gcpro gcpro1, gcpro2;
237

238 239
	  GCPRO2 (tem, object);
	  do_autoload (tem, object);
240 241 242 243
	  UNGCPRO;

	  goto autoload_retry;
	}
244 245
    }

Jim Blandy's avatar
Jim Blandy committed
246 247
  if (error)
    wrong_type_argument (Qkeymapp, object);
Jim Blandy's avatar
Jim Blandy committed
248 249
  else
    return Qnil;
Jim Blandy's avatar
Jim Blandy committed
250 251
}

252 253 254

/* Follow any symbol chaining, and return the keymap denoted by OBJECT.
   If OBJECT doesn't denote a keymap at all, signal an error.  */
Jim Blandy's avatar
Jim Blandy committed
255 256 257 258
Lisp_Object
get_keymap (object)
     Lisp_Object object;
{
259
  return get_keymap_1 (object, 1, 0);
Jim Blandy's avatar
Jim Blandy committed
260 261 262 263
}


/* Look up IDX in MAP.  IDX may be any sort of event.
264
   Note that this does only one level of lookup; IDX must be a single
265 266 267 268 269 270
   event, not a sequence. 

   If T_OK is non-zero, bindings for Qt are treated as default
   bindings; any key left unmentioned by other tables and bindings is
   given the binding of Qt.  

271 272 273
   If T_OK is zero, bindings for Qt are not treated specially.

   If NOINHERIT, don't accept a subkeymap found in an inherited keymap.  */
Jim Blandy's avatar
Jim Blandy committed
274 275

Lisp_Object
276
access_keymap (map, idx, t_ok, noinherit)
Jim Blandy's avatar
Jim Blandy committed
277 278
     Lisp_Object map;
     Lisp_Object idx;
279
     int t_ok;
280
     int noinherit;
Jim Blandy's avatar
Jim Blandy committed
281
{
282 283 284
  int noprefix = 0;
  Lisp_Object val;

Jim Blandy's avatar
Jim Blandy committed
285 286 287
  /* If idx is a list (some sort of mouse click, perhaps?),
     the index we want to use is the car of the list, which
     ought to be a symbol.  */
288
  idx = EVENT_HEAD (idx);
Jim Blandy's avatar
Jim Blandy committed
289

290 291
  /* If idx is a symbol, it might have modifiers, which need to
     be put in the canonical order.  */
292
  if (SYMBOLP (idx))
293
    idx = reorder_modifiers (idx);
294 295 296
  else if (INTEGERP (idx))
    /* Clobber the high bits that can be present on a machine
       with more than 24 bits of integer.  */
297
    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
Jim Blandy's avatar
Jim Blandy committed
298

299 300
  {
    Lisp_Object tail;
301
    Lisp_Object t_binding;
Jim Blandy's avatar
Jim Blandy committed
302

303
    t_binding = Qnil;
304
    for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
Jim Blandy's avatar
Jim Blandy committed
305
      {
306
	Lisp_Object binding;
307

308
	binding = XCONS (tail)->car;
309
	if (SYMBOLP (binding))
310
	  {
311 312 313 314
	    /* If NOINHERIT, stop finding prefix definitions
	       after we pass a second occurrence of the `keymap' symbol.  */
	    if (noinherit && EQ (binding, Qkeymap) && ! EQ (tail, map))
	      noprefix = 1;
315 316 317
	  }
	else if (CONSP (binding))
	  {
318
	    if (EQ (XCONS (binding)->car, idx))
319 320 321 322 323 324
	      {
		val = XCONS (binding)->cdr;
		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
		  return Qnil;
		return val;
	      }
325 326
	    if (t_ok && EQ (XCONS (binding)->car, Qt))
	      t_binding = XCONS (binding)->cdr;
327 328 329
	  }
	else if (VECTORP (binding))
	  {
330
	    if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (binding)->size)
331
	      {
332
		val = XVECTOR (binding)->contents[XFASTINT (idx)];
333 334 335 336
		if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
		  return Qnil;
		return val;
	      }
337
	  }
338 339

	QUIT;
Jim Blandy's avatar
Jim Blandy committed
340
      }
341

342 343
    return t_binding;
  }
Jim Blandy's avatar
Jim Blandy committed
344 345 346 347 348 349 350 351 352
}

/* Given OBJECT which was found in a slot in a keymap,
   trace indirect definitions to get the actual definition of that slot.
   An indirect definition is a list of the form
   (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
   and INDEX is the object to look up in KEYMAP to yield the definition.

   Also if OBJECT has a menu string as the first element,
353 354 355 356
   remove that.  Also remove a menu help string as second element.

   If AUTOLOAD is nonzero, load autoloadable keymaps
   that are referred to with indirection.  */
Jim Blandy's avatar
Jim Blandy committed
357 358

Lisp_Object
359
get_keyelt (object, autoload)
Jim Blandy's avatar
Jim Blandy committed
360
     register Lisp_Object object;
361
     int autoload;
Jim Blandy's avatar
Jim Blandy committed
362 363 364 365 366
{
  while (1)
    {
      register Lisp_Object map, tem;

367
      /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
368
      map = get_keymap_1 (Fcar_safe (object), 0, autoload);
Jim Blandy's avatar
Jim Blandy committed
369
      tem = Fkeymapp (map);
Jim Blandy's avatar
Jim Blandy committed
370
      if (!NILP (tem))
371
	object = access_keymap (map, Fcdr (object), 0, 0);
Jim Blandy's avatar
Jim Blandy committed
372 373 374 375 376
      
      /* If the keymap contents looks like (STRING . DEFN),
	 use DEFN.
	 Keymap alist elements like (CHAR MENUSTRING . DEFN)
	 will be used by HierarKey menus.  */
377 378
      else if (CONSP (object)
	       && STRINGP (XCONS (object)->car))
379 380 381 382
	{
	  object = XCONS (object)->cdr;
	  /* Also remove a menu help string, if any,
	     following the menu item name.  */
383
	  if (CONSP (object) && STRINGP (XCONS (object)->car))
384
	    object = XCONS (object)->cdr;
385 386 387
	  /* Also remove the sublist that caches key equivalences, if any.  */
	  if (CONSP (object)
	      && CONSP (XCONS (object)->car))
388
	    {
389 390 391
	      Lisp_Object carcar;
	      carcar = XCONS (XCONS (object)->car)->car;
	      if (NILP (carcar) || VECTORP (carcar))
392 393
		object = XCONS (object)->cdr;
	    }
394
	}
Jim Blandy's avatar
Jim Blandy committed
395 396 397 398 399 400 401 402 403 404 405 406 407

      else
	/* Anything else is really the value.  */
	return object;
    }
}

Lisp_Object
store_in_keymap (keymap, idx, def)
     Lisp_Object keymap;
     register Lisp_Object idx;
     register Lisp_Object def;
{
408 409
  /* If we are preparing to dump, and DEF is a menu element
     with a menu item string, copy it to ensure it is not pure.  */
410
  if (CONSP (def) && PURE_P (def) && STRINGP (XCONS (def)->car))
411 412
    def = Fcons (XCONS (def)->car, XCONS (def)->cdr);

413
  if (!CONSP (keymap) || ! EQ (XCONS (keymap)->car, Qkeymap))
414 415
    error ("attempt to define a key in a non-keymap");

Jim Blandy's avatar
Jim Blandy committed
416 417 418
  /* If idx is a list (some sort of mouse click, perhaps?),
     the index we want to use is the car of the list, which
     ought to be a symbol.  */
419
  idx = EVENT_HEAD (idx);
Jim Blandy's avatar
Jim Blandy committed
420

421 422
  /* If idx is a symbol, it might have modifiers, which need to
     be put in the canonical order.  */
423
  if (SYMBOLP (idx))
424
    idx = reorder_modifiers (idx);
425 426 427
  else if (INTEGERP (idx))
    /* Clobber the high bits that can be present on a machine
       with more than 24 bits of integer.  */
428
    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
429 430

  /* Scan the keymap for a binding of idx.  */
Jim Blandy's avatar
Jim Blandy committed
431
  {
432
    Lisp_Object tail;
Jim Blandy's avatar
Jim Blandy committed
433

434 435 436 437 438 439
    /* The cons after which we should insert new bindings.  If the
       keymap has a table element, we record its position here, so new
       bindings will go after it; this way, the table will stay
       towards the front of the alist and character lookups in dense
       keymaps will remain fast.  Otherwise, this just points at the
       front of the keymap.  */
440
    Lisp_Object insertion_point;
Jim Blandy's avatar
Jim Blandy committed
441

442
    insertion_point = keymap;
443
    for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
Jim Blandy's avatar
Jim Blandy committed
444
      {
445
	Lisp_Object elt;
446

447
	elt = XCONS (tail)->car;
448
	if (VECTORP (elt))
449
	  {
450
	    if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)
451 452 453 454 455
	      {
		XVECTOR (elt)->contents[XFASTINT (idx)] = def;
		return def;
	      }
	    insertion_point = tail;
456 457 458
	  }
	else if (CONSP (elt))
	  {
459 460 461 462 463
	    if (EQ (idx, XCONS (elt)->car))
	      {
		XCONS (elt)->cdr = def;
		return def;
	      }
464 465 466
	  }
	else if (SYMBOLP (elt))
	  {
467 468 469 470 471 472 473
	    /* If we find a 'keymap' symbol in the spine of KEYMAP,
               then we must have found the start of a second keymap
               being used as the tail of KEYMAP, and a binding for IDX
               should be inserted before it.  */
	    if (EQ (elt, Qkeymap))
	      goto keymap_end;
	  }
474 475

	QUIT;
Jim Blandy's avatar
Jim Blandy committed
476 477
      }

478 479 480
  keymap_end:
    /* We have scanned the entire keymap, and not found a binding for
       IDX.  Let's add one.  */
481 482
    XCONS (insertion_point)->cdr
      = Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr);
483 484
  }
	  
Jim Blandy's avatar
Jim Blandy committed
485 486 487
  return def;
}

488

Jim Blandy's avatar
Jim Blandy committed
489 490 491 492
DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
  "Return a copy of the keymap KEYMAP.\n\
The copy starts out with the same definitions of KEYMAP,\n\
but changing either the copy or KEYMAP does not affect the other.\n\
Jim Blandy's avatar
Jim Blandy committed
493 494 495
Any key definitions that are subkeymaps are recursively copied.\n\
However, a key definition which is a symbol whose definition is a keymap\n\
is not copied.")
Jim Blandy's avatar
Jim Blandy committed
496 497 498 499 500 501 502
  (keymap)
     Lisp_Object keymap;
{
  register Lisp_Object copy, tail;

  copy = Fcopy_alist (get_keymap (keymap));

503
  for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
Jim Blandy's avatar
Jim Blandy committed
504
    {
505
      Lisp_Object elt;
Jim Blandy's avatar
Jim Blandy committed
506

507
      elt = XCONS (tail)->car;
508
      if (VECTORP (elt))
Jim Blandy's avatar
Jim Blandy committed
509
	{
510
	  int i;
Jim Blandy's avatar
Jim Blandy committed
511

512 513
	  elt = Fcopy_sequence (elt);
	  XCONS (tail)->car = elt;
Jim Blandy's avatar
Jim Blandy committed
514

515
	  for (i = 0; i < XVECTOR (elt)->size; i++)
516
	    if (!SYMBOLP (XVECTOR (elt)->contents[i])
517
		&& ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
518 519
	      XVECTOR (elt)->contents[i] =
		Fcopy_keymap (XVECTOR (elt)->contents[i]);
Jim Blandy's avatar
Jim Blandy committed
520
	}
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
      else if (CONSP (elt))
	{
	  /* Skip the optional menu string.  */
	  if (CONSP (XCONS (elt)->cdr)
	      && STRINGP (XCONS (XCONS (elt)->cdr)->car))
	    {
	      Lisp_Object tem;

	      /* Copy the cell, since copy-alist didn't go this deep.  */
	      XCONS (elt)->cdr = Fcons (XCONS (XCONS (elt)->cdr)->car,
					XCONS (XCONS (elt)->cdr)->cdr);
	      elt = XCONS (elt)->cdr;

	      /* Also skip the optional menu help string.  */
	      if (CONSP (XCONS (elt)->cdr)
		  && STRINGP (XCONS (XCONS (elt)->cdr)->car))
		{
		  XCONS (elt)->cdr = Fcons (XCONS (XCONS (elt)->cdr)->car,
					    XCONS (XCONS (elt)->cdr)->cdr);
		  elt = XCONS (elt)->cdr;
		}
	      /* There may also be a list that caches key equivalences.
		 Just delete it for the new keymap.  */
	      if (CONSP (XCONS (elt)->cdr)
		  && CONSP (XCONS (XCONS (elt)->cdr)->car)
		  && (NILP (tem = XCONS (XCONS (XCONS (elt)->cdr)->car)->car)
		      || VECTORP (tem)))
		XCONS (elt)->cdr = XCONS (XCONS (elt)->cdr)->cdr;
	    }
	  if (CONSP (elt)
	      && ! SYMBOLP (XCONS (elt)->cdr)
	      && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
	    XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
	}
Jim Blandy's avatar
Jim Blandy committed
555 556 557 558 559
    }

  return copy;
}

Jim Blandy's avatar
Jim Blandy committed
560 561
/* Simple Keymap mutators and accessors.				*/

562 563
/* GC is possible in this function if it autoloads a keymap.  */

Jim Blandy's avatar
Jim Blandy committed
564 565 566 567
DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
  "Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.\n\
KEYMAP is a keymap.  KEY is a string or a vector of symbols and characters\n\
meaning a sequence of keystrokes and events.\n\
Richard M. Stallman's avatar
Richard M. Stallman committed
568 569
Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
can be included if you use a vector.\n\
Jim Blandy's avatar
Jim Blandy committed
570 571 572 573 574 575 576 577 578 579
DEF is anything that can be a key's definition:\n\
 nil (means key is undefined in this keymap),\n\
 a command (a Lisp function suitable for interactive calling)\n\
 a string (treated as a keyboard macro),\n\
 a keymap (to define a prefix key),\n\
 a symbol.  When the key is looked up, the symbol will stand for its\n\
    function definition, which should at that time be one of the above,\n\
    or another symbol whose function definition is used, etc.\n\
 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
    (DEFN should be a valid definition in its own right),\n\
Jim Blandy's avatar
Jim Blandy committed
580 581 582 583
 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
\n\
If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
the front of KEYMAP.")
Jim Blandy's avatar
Jim Blandy committed
584
  (keymap, key, def)
585
     Lisp_Object keymap;
Jim Blandy's avatar
Jim Blandy committed
586 587 588 589 590 591 592 593
     Lisp_Object key;
     Lisp_Object def;
{
  register int idx;
  register Lisp_Object c;
  register Lisp_Object tem;
  register Lisp_Object cmd;
  int metized = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
594
  int meta_bit;
Jim Blandy's avatar
Jim Blandy committed
595
  int length;
596
  struct gcpro gcpro1, gcpro2, gcpro3;
Jim Blandy's avatar
Jim Blandy committed
597

598
  keymap = get_keymap_1 (keymap, 1, 1);
Jim Blandy's avatar
Jim Blandy committed
599

600
  if (!VECTORP (key) && !STRINGP (key))
Jim Blandy's avatar
Jim Blandy committed
601 602
    key = wrong_type_argument (Qarrayp, key);

603
  length = XFASTINT (Flength (key));
Jim Blandy's avatar
Jim Blandy committed
604 605 606
  if (length == 0)
    return Qnil;

607 608 609
  if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
    Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);

610 611
  GCPRO3 (keymap, key, def);

612
  if (VECTORP (key))
Richard M. Stallman's avatar
Richard M. Stallman committed
613 614 615 616
    meta_bit = meta_modifier;
  else
    meta_bit = 0x80;

Jim Blandy's avatar
Jim Blandy committed
617 618 619 620 621
  idx = 0;
  while (1)
    {
      c = Faref (key, make_number (idx));

622
      if (CONSP (c) && lucid_event_type_list_p (c))
623
	c = Fevent_convert_list (c);
624

625
      if (INTEGERP (c)
Richard M. Stallman's avatar
Richard M. Stallman committed
626
	  && (XINT (c) & meta_bit)
Jim Blandy's avatar
Jim Blandy committed
627 628 629 630 631 632 633
	  && !metized)
	{
	  c = meta_prefix_char;
	  metized = 1;
	}
      else
	{
634
	  if (INTEGERP (c))
635
	    XSETINT (c, XINT (c) & ~meta_bit);
Jim Blandy's avatar
Jim Blandy committed
636 637 638 639 640

	  metized = 0;
	  idx++;
	}

641
      if (! INTEGERP (c) && ! SYMBOLP (c) && ! CONSP (c))
642
	error ("Key sequence contains invalid events");
643

Jim Blandy's avatar
Jim Blandy committed
644
      if (idx == length)
645
	RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
Jim Blandy's avatar
Jim Blandy committed
646

647
      cmd = get_keyelt (access_keymap (keymap, c, 0, 1), 1);
Jim Blandy's avatar
Jim Blandy committed
648

649
      /* If this key is undefined, make it a prefix.  */
Jim Blandy's avatar
Jim Blandy committed
650
      if (NILP (cmd))
651
	cmd = define_as_prefix (keymap, c);
Jim Blandy's avatar
Jim Blandy committed
652

653 654
      keymap = get_keymap_1 (cmd, 0, 1);
      if (NILP (keymap))
655 656 657 658
	/* We must use Fkey_description rather than just passing key to
	   error; key might be a vector, not a string.  */
	error ("Key sequence %s uses invalid prefix characters",
	       XSTRING (Fkey_description (key))->data);
Jim Blandy's avatar
Jim Blandy committed
659 660 661 662
    }
}

/* Value is number if KEY is too long; NIL if valid but has no definition. */
663
/* GC is possible in this function if it autoloads a keymap.  */
Jim Blandy's avatar
Jim Blandy committed
664

665
DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
Jim Blandy's avatar
Jim Blandy committed
666 667
  "In keymap KEYMAP, look up key sequence KEY.  Return the definition.\n\
nil means undefined.  See doc of `define-key' for kinds of definitions.\n\
668
\n\
Jim Blandy's avatar
Jim Blandy committed
669 670 671 672
A number as value means KEY is \"too long\";\n\
that is, characters or symbols in it except for the last one\n\
fail to be a valid sequence of prefix characters in KEYMAP.\n\
The number is how many characters at the front of KEY\n\
673 674 675 676
it takes to reach a non-prefix command.\n\
\n\
Normally, `lookup-key' ignores bindings for t, which act as default\n\
bindings, used when nothing else in the keymap applies; this makes it\n\
Karl Heuer's avatar
Karl Heuer committed
677
usable as a general function for probing keymaps.  However, if the\n\
678 679 680
third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
recognize the default bindings, just as `read-key-sequence' does.")
  (keymap, key, accept_default)
Jim Blandy's avatar
Jim Blandy committed
681 682
     register Lisp_Object keymap;
     Lisp_Object key;
683
     Lisp_Object accept_default;
Jim Blandy's avatar
Jim Blandy committed
684 685 686 687 688 689 690
{
  register int idx;
  register Lisp_Object tem;
  register Lisp_Object cmd;
  register Lisp_Object c;
  int metized = 0;
  int length;
691
  int t_ok = ! NILP (accept_default);
Richard M. Stallman's avatar
Richard M. Stallman committed
692
  int meta_bit;
693
  struct gcpro gcpro1;
Jim Blandy's avatar
Jim Blandy committed
694

695
  keymap = get_keymap_1 (keymap, 1, 1);
Jim Blandy's avatar
Jim Blandy committed
696

697
  if (!VECTORP (key) && !STRINGP (key))
Jim Blandy's avatar
Jim Blandy committed
698 699
    key = wrong_type_argument (Qarrayp, key);

700
  length = XFASTINT (Flength (key));
Jim Blandy's avatar
Jim Blandy committed
701 702 703
  if (length == 0)
    return keymap;

704
  if (VECTORP (key))
Richard M. Stallman's avatar
Richard M. Stallman committed
705 706 707 708
    meta_bit = meta_modifier;
  else
    meta_bit = 0x80;

709 710
  GCPRO1 (key);

Jim Blandy's avatar
Jim Blandy committed
711 712 713 714 715
  idx = 0;
  while (1)
    {
      c = Faref (key, make_number (idx));

716
      if (CONSP (c) && lucid_event_type_list_p (c))
717
	c = Fevent_convert_list (c);
718

719
      if (INTEGERP (c)
Richard M. Stallman's avatar
Richard M. Stallman committed
720
	  && (XINT (c) & meta_bit)
Jim Blandy's avatar
Jim Blandy committed
721 722 723 724 725 726 727
	  && !metized)
	{
	  c = meta_prefix_char;
	  metized = 1;
	}
      else
	{
728
	  if (INTEGERP (c))
Richard M. Stallman's avatar
Richard M. Stallman committed
729
	    XSETINT (c, XINT (c) & ~meta_bit);
Jim Blandy's avatar
Jim Blandy committed
730 731 732 733 734

	  metized = 0;
	  idx++;
	}

735
      cmd = get_keyelt (access_keymap (keymap, c, t_ok, 0), 1);
Jim Blandy's avatar
Jim Blandy committed
736
      if (idx == length)
737
	RETURN_UNGCPRO (cmd);
Jim Blandy's avatar
Jim Blandy committed
738

739
      keymap = get_keymap_1 (cmd, 0, 1);
740
      if (NILP (keymap))
741
	RETURN_UNGCPRO (make_number (idx));
Jim Blandy's avatar
Jim Blandy committed
742 743 744 745 746

      QUIT;
    }
}

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
/* Make KEYMAP define event C as a keymap (i.e., as a prefix).
   Assume that currently it does not define C at all.
   Return the keymap.  */

static Lisp_Object
define_as_prefix (keymap, c)
     Lisp_Object keymap, c;
{
  Lisp_Object inherit, cmd;

  cmd = Fmake_sparse_keymap (Qnil);
  /* If this key is defined as a prefix in an inherited keymap,
     make it a prefix in this map, and make its definition
     inherit the other prefix definition.  */
  inherit = access_keymap (keymap, c, 0, 0);
  if (NILP (inherit))
    {
      /* If there's an inherited keymap
	 and it doesn't define this key,
	 make it define this key.  */
      Lisp_Object tail;

      for (tail = Fcdr (keymap); CONSP (tail); tail = XCONS (tail)->cdr)
	if (EQ (XCONS (tail)->car, Qkeymap))
	  break;

      if (!NILP (tail))
	inherit = define_as_prefix (tail, c);
    }

  cmd = nconc2 (cmd, inherit);
  store_in_keymap (keymap, c, cmd);

  return cmd;
}

783 784
/* Append a key to the end of a key sequence.  We always make a vector.  */

Jim Blandy's avatar
Jim Blandy committed
785 786 787 788 789 790 791 792
Lisp_Object
append_key (key_sequence, key)
     Lisp_Object key_sequence, key;
{
  Lisp_Object args[2];

  args[0] = key_sequence;

793 794
  args[1] = Fcons (key, Qnil);
  return Fvconcat (2, args);
Jim Blandy's avatar
Jim Blandy committed
795 796 797
}


Jim Blandy's avatar
Jim Blandy committed
798 799
/* Global, local, and minor mode keymap stuff.				*/

Jim Blandy's avatar
Jim Blandy committed
800
/* We can't put these variables inside current_minor_maps, since under
Jim Blandy's avatar
Jim Blandy committed
801 802
   some systems, static gets macro-defined to be the empty string.
   Ickypoo.  */
Jim Blandy's avatar
Jim Blandy committed
803 804 805
static Lisp_Object *cmm_modes, *cmm_maps;
static int cmm_size;

806 807 808 809 810 811 812
/* Error handler used in current_minor_maps.  */
static Lisp_Object
current_minor_maps_error ()
{
  return Qnil;
}

Jim Blandy's avatar
Jim Blandy committed
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
/* Store a pointer to an array of the keymaps of the currently active
   minor modes in *buf, and return the number of maps it contains.

   This function always returns a pointer to the same buffer, and may
   free or reallocate it, so if you want to keep it for a long time or
   hand it out to lisp code, copy it.  This procedure will be called
   for every key sequence read, so the nice lispy approach (return a
   new assoclist, list, what have you) for each invocation would
   result in a lot of consing over time.

   If we used xrealloc/xmalloc and ran out of memory, they would throw
   back to the command loop, which would try to read a key sequence,
   which would call this function again, resulting in an infinite
   loop.  Instead, we'll use realloc/malloc and silently truncate the
   list, let the key sequence be read, and hope some other piece of
   code signals the error.  */
int
current_minor_maps (modeptr, mapptr)
     Lisp_Object **modeptr, **mapptr;
{
  int i = 0;
Jim Blandy's avatar
Jim Blandy committed
834
  Lisp_Object alist, assoc, var, val;
Jim Blandy's avatar
Jim Blandy committed
835 836 837 838

  for (alist = Vminor_mode_map_alist;
       CONSP (alist);
       alist = XCONS (alist)->cdr)
839 840 841
    if ((assoc = XCONS (alist)->car, CONSP (assoc))
	&& (var = XCONS (assoc)->car, SYMBOLP (var))
	&& (val = find_symbol_value (var), ! EQ (val, Qunbound))
Jim Blandy's avatar
Jim Blandy committed
842
	&& ! NILP (val))
Jim Blandy's avatar
Jim Blandy committed
843
      {
844 845
	Lisp_Object temp;

Jim Blandy's avatar
Jim Blandy committed
846
	if (i >= cmm_size)
Jim Blandy's avatar
Jim Blandy committed
847 848 849
	  {
	    Lisp_Object *newmodes, *newmaps;

Jim Blandy's avatar
Jim Blandy committed
850
	    if (cmm_maps)
Jim Blandy's avatar
Jim Blandy committed
851
	      {
852
		BLOCK_INPUT;
853
		cmm_size *= 2;
Richard M. Stallman's avatar
Richard M. Stallman committed
854 855 856 857 858 859
		newmodes
		  = (Lisp_Object *) realloc (cmm_modes,
					     cmm_size * sizeof (Lisp_Object));
		newmaps
		  = (Lisp_Object *) realloc (cmm_maps,
					     cmm_size * sizeof (Lisp_Object));
860
		UNBLOCK_INPUT;
Jim Blandy's avatar
Jim Blandy committed
861 862 863
	      }
	    else
	      {
864
		BLOCK_INPUT;
865
		cmm_size = 30;
Richard M. Stallman's avatar
Richard M. Stallman committed
866 867 868 869
		newmodes
		  = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
		newmaps
		  = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
870
		UNBLOCK_INPUT;
Jim Blandy's avatar
Jim Blandy committed
871 872 873 874
	      }

	    if (newmaps && newmodes)
	      {
Jim Blandy's avatar
Jim Blandy committed
875 876
		cmm_modes = newmodes;
		cmm_maps = newmaps;
Jim Blandy's avatar
Jim Blandy committed
877 878 879 880
	      }
	    else
	      break;
	  }
881 882 883 884 885 886 887 888 889 890 891

	/* Get the keymap definition--or nil if it is not defined.  */
	temp = internal_condition_case_1 (Findirect_function,
					  XCONS (assoc)->cdr,
					  Qerror, current_minor_maps_error);
	if (!NILP (temp))
	  {
	    cmm_modes[i] = var;
	    cmm_maps [i] = temp;
	    i++;
	  }
Jim Blandy's avatar
Jim Blandy committed
892 893
      }

Jim Blandy's avatar
Jim Blandy committed
894 895
  if (modeptr) *modeptr = cmm_modes;
  if (mapptr)  *mapptr  = cmm_maps;
Jim Blandy's avatar
Jim Blandy committed
896 897 898
  return i;
}

899 900
/* GC is possible in this function if it autoloads a keymap.  */

901
DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
Jim Blandy's avatar
Jim Blandy committed
902
  "Return the binding for command KEY in current keymaps.\n\
903 904 905 906 907
KEY is a string or vector, a sequence of keystrokes.\n\
The binding is probably a symbol with a function definition.\n\
\n\
Normally, `key-binding' ignores bindings for t, which act as default\n\
bindings, used when nothing else in the keymap applies; this makes it\n\
Richard M. Stallman's avatar
Richard M. Stallman committed
908 909
usable as a general function for probing keymaps.  However, if the\n\
optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
910 911
recognize the default bindings, just as `read-key-sequence' does.")
  (key, accept_default)
912
     Lisp_Object key, accept_default;
Jim Blandy's avatar
Jim Blandy committed
913
{
Jim Blandy's avatar
Jim Blandy committed
914 915
  Lisp_Object *maps, value;
  int nmaps, i;
916 917 918
  struct gcpro gcpro1;

  GCPRO1 (key);
Jim Blandy's avatar
Jim Blandy committed
919

920 921 922 923 924 925 926 927
  if (!NILP (current_kboard->Voverriding_terminal_local_map))
    {
      value = Flookup_key (current_kboard->Voverriding_terminal_local_map,
			   key, accept_default);
      if (! NILP (value) && !INTEGERP (value))
	RETURN_UNGCPRO (value);
    }
  else if (!NILP (Voverriding_local_map))
Jim Blandy's avatar
Jim Blandy committed
928
    {
929
      value = Flookup_key (Voverriding_local_map, key, accept_default);
930
      if (! NILP (value) && !INTEGERP (value))
931
	RETURN_UNGCPRO (value);
Jim Blandy's avatar
Jim Blandy committed
932
    }
933 934
  else
    { 
935 936
      Lisp_Object local;

937
      nmaps = current_minor_maps (0, &maps);
938 939 940
      /* Note that all these maps are GCPRO'd
	 in the places where we found them.  */

941 942 943 944
      for (i = 0; i < nmaps; i++)
	if (! NILP (maps[i]))
	  {
	    value = Flookup_key (maps[i], key, accept_default);
945
	    if (! NILP (value) && !INTEGERP (value))
946
	      RETURN_UNGCPRO (value);
947 948
	  }

949 950 951
      local = get_local_map (PT, current_buffer);

      if (! NILP (local))
952
	{
953
	  value = Flookup_key (local, key, accept_default);
954
	  if (! NILP (value) && !INTEGERP (value))
955
	    RETURN_UNGCPRO (value);
956 957
	}
    }
Jim Blandy's avatar
Jim Blandy committed
958

959
  value = Flookup_key (current_global_map, key, accept_default);
960
  UNGCPRO;
961
  if (! NILP (value) && !INTEGERP (value))
Jim Blandy's avatar
Jim Blandy committed
962 963 964
    return value;
  
  return Qnil;
Jim Blandy's avatar
Jim Blandy committed
965 966
}

967 968
/* GC is possible in this function if it autoloads a keymap.  */

969
DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
Jim Blandy's avatar
Jim Blandy committed
970 971
  "Return the binding for command KEYS in current local keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
972 973 974 975 976 977
The binding is probably a symbol with a function definition.\n\
\n\
If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
bindings; see the description of `lookup-key' for more details about this.")
  (keys, accept_default)
     Lisp_Object keys, accept_default;
Jim Blandy's avatar
Jim Blandy committed
978 979 980
{
  register Lisp_Object map;
  map = current_buffer->keymap;
Jim Blandy's avatar
Jim Blandy committed
981
  if (NILP (map))
Jim Blandy's avatar
Jim Blandy committed
982
    return Qnil;
983
  return Flookup_key (map, keys, accept_default);
Jim Blandy's avatar
Jim Blandy committed
984 985
}

986 987
/* GC is possible in this function if it autoloads a keymap.  */

988
DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
Jim Blandy's avatar
Jim Blandy committed
989 990
  "Return the binding for command KEYS in current global keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
Jim Blandy's avatar
Jim Blandy committed
991 992
The binding is probably a symbol with a function definition.\n\
This function's return values are the same as those of lookup-key\n\
993
\(which see).\n\
994 995 996 997 998
\n\
If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
bindings; see the description of `lookup-key' for more details about this.")
  (keys, accept_default)
     Lisp_Object keys, accept_default;
Jim Blandy's avatar
Jim Blandy committed
999
{
1000
  return Flookup_key (current_global_map, keys, accept_default);
Jim Blandy's avatar
Jim Blandy committed
1001 1002
}

1003 1004
/* GC is possible in this function if it autoloads a keymap.  */

1005
DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
Jim Blandy's avatar
Jim Blandy committed
1006 1007 1008 1009 1010 1011 1012
  "Find the visible minor mode bindings of KEY.\n\
Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
the symbol which names the minor mode binding KEY, and BINDING is\n\
KEY's definition in that mode.  In particular, if KEY has no\n\
minor-mode bindings, return nil.  If the first binding is a\n\
non-prefix, all subsequent bindings will be omitted, since they would\n\
be ignored.  Similarly, the list doesn't include non-prefix bindings\n\
1013 1014 1015 1016 1017 1018
that come after prefix bindings.\n\
\n\
If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
bindings; see the description of `lookup-key' for more details about this.")
  (key, accept_default)
     Lisp_Object key, accept_default;
Jim Blandy's avatar
Jim Blandy committed
1019 1020 1021 1022 1023
{
  Lisp_Object *modes, *maps;
  int nmaps;
  Lisp_Object binding;
  int i, j;
1024
  struct gcpro gcpro1, gcpro2;
Jim Blandy's avatar
Jim Blandy committed
1025 1026

  nmaps = current_minor_maps (&modes, &maps);
1027 1028 1029 1030 1031