src/keymap.c

   1 /* Manipulation of keymaps
   2    Copyright (C) 1985, 86,87,88,93,94,95,98,99 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #undef NULL
  25 #include "lisp.h"
  26 #include "commands.h"
  27 #include "buffer.h"
  28 #include "charset.h"
  29 #include "keyboard.h"
  30 #include "termhooks.h"
  31 #include "blockinput.h"
  32 #include "puresize.h"
  33 #include "intervals.h"
  34
  35 #define min(a, b) ((a) < (b) ? (a) : (b))
  36 #define KEYMAPP(m) (!NILP (Fkeymapp (m)))
  37
  38 /* The number of elements in keymap vectors.  */
  39 #define DENSE_TABLE_SIZE (0200)
  40
  41 /* Actually allocate storage for these variables */
  42
  43 Lisp_Object current_global_map; /* Current global keymap */
  44
  45 Lisp_Object global_map;         /* default global key bindings */
  46
  47 Lisp_Object meta_map;           /* The keymap used for globally bound
  48                                    ESC-prefixed default commands */
  49
  50 Lisp_Object control_x_map;      /* The keymap used for globally bound
  51                                    C-x-prefixed default commands */
  52
  53 /* was MinibufLocalMap */
  54 Lisp_Object Vminibuffer_local_map;
  55                                 /* The keymap used by the minibuf for local
  56                                    bindings when spaces are allowed in the
  57                                    minibuf */
  58
  59 /* was MinibufLocalNSMap */
  60 Lisp_Object Vminibuffer_local_ns_map;
  61                                 /* The keymap used by the minibuf for local
  62                                    bindings when spaces are not encouraged
  63                                    in the minibuf */
  64
  65 /* keymap used for minibuffers when doing completion */
  66 /* was MinibufLocalCompletionMap */
  67 Lisp_Object Vminibuffer_local_completion_map;
  68
  69 /* keymap used for minibuffers when doing completion and require a match */
  70 /* was MinibufLocalMustMatchMap */
  71 Lisp_Object Vminibuffer_local_must_match_map;
  72
  73 /* Alist of minor mode variables and keymaps.  */
  74 Lisp_Object Vminor_mode_map_alist;
  75
  76 /* Alist of major-mode-specific overrides for
  77    minor mode variables and keymaps.  */
  78 Lisp_Object Vminor_mode_overriding_map_alist;
  79
  80 /* Keymap mapping ASCII function key sequences onto their preferred forms.
  81    Initialized by the terminal-specific lisp files.  See DEFVAR for more
  82    documentation.  */
  83 Lisp_Object Vfunction_key_map;
  84
  85 /* Keymap mapping ASCII function key sequences onto their preferred forms.  */
  86 Lisp_Object Vkey_translation_map;
  87
  88 /* A list of all commands given new bindings since a certain time
  89    when nil was stored here.
  90    This is used to speed up recomputation of menu key equivalents
  91    when Emacs starts up.   t means don't record anything here.  */
  92 Lisp_Object Vdefine_key_rebound_commands;
  93
  94 Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii, Qmenu_item;
  95
  96 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
  97    in a string key sequence is equivalent to prefixing with this
  98    character.  */
  99 extern Lisp_Object meta_prefix_char;
 100
 101 extern Lisp_Object Voverriding_local_map;
 102
 103 static Lisp_Object store_in_keymap P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
 104 static void fix_submap_inheritance P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
 105
 106 static Lisp_Object define_as_prefix P_ ((Lisp_Object, Lisp_Object));
 107 static Lisp_Object describe_buffer_bindings P_ ((Lisp_Object));
 108 static void describe_command P_ ((Lisp_Object));
 109 static void describe_translation P_ ((Lisp_Object));
 110 static void describe_map P_ ((Lisp_Object, Lisp_Object,
 111                               void (*) P_ ((Lisp_Object)),
 112                               int, Lisp_Object, Lisp_Object*, int));
 113 \f
 114 /* Keymap object support - constructors and predicates.                 */
 115
 116 DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,
 117   "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
 118 CHARTABLE is a char-table that holds the bindings for the ASCII\n\
 119 characters.  ALIST is an assoc-list which holds bindings for function keys,\n\
 120 mouse events, and any other things that appear in the input stream.\n\
 121 All entries in it are initially nil, meaning \"command undefined\".\n\n\
 122 The optional arg STRING supplies a menu name for the keymap\n\
 123 in case you use it as a menu with `x-popup-menu'.")
 124   (string)
 125      Lisp_Object string;
 126 {
 127   Lisp_Object tail;
 128   if (!NILP (string))
 129     tail = Fcons (string, Qnil);
 130   else
 131     tail = Qnil;
 132   return Fcons (Qkeymap,
 133                 Fcons (Fmake_char_table (Qkeymap, Qnil), tail));
 134 }
 135
 136 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
 137   "Construct and return a new sparse-keymap list.\n\
 138 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
 139 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
 140 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
 141 Initially the alist is nil.\n\n\
 142 The optional arg STRING supplies a menu name for the keymap\n\
 143 in case you use it as a menu with `x-popup-menu'.")
 144   (string)
 145      Lisp_Object string;
 146 {
 147   if (!NILP (string))
 148     return Fcons (Qkeymap, Fcons (string, Qnil));
 149   return Fcons (Qkeymap, Qnil);
 150 }
 151
 152 /* This function is used for installing the standard key bindings
 153    at initialization time.
 154
 155    For example:
 156
 157    initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark");  */
 158
 159 void
 160 initial_define_key (keymap, key, defname)
 161      Lisp_Object keymap;
 162      int key;
 163      char *defname;
 164 {
 165   store_in_keymap (keymap, make_number (key), intern (defname));
 166 }
 167
 168 void
 169 initial_define_lispy_key (keymap, keyname, defname)
 170      Lisp_Object keymap;
 171      char *keyname;
 172      char *defname;
 173 {
 174   store_in_keymap (keymap, intern (keyname), intern (defname));
 175 }
 176
 177 /* Define character fromchar in map frommap as an alias for character
 178    tochar in map tomap.  Subsequent redefinitions of the latter WILL
 179    affect the former. */
 180
 181 #if 0
 182 void
 183 synkey (frommap, fromchar, tomap, tochar)
 184      struct Lisp_Vector *frommap, *tomap;
 185      int fromchar, tochar;
 186 {
 187   Lisp_Object v, c;
 188   XSETVECTOR (v, tomap);
 189   XSETFASTINT (c, tochar);
 190   frommap->contents[fromchar] = Fcons (v, c);
 191 }
 192 #endif /* 0 */
 193
 194 DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
 195   "Return t if OBJECT is a keymap.\n\
 196 \n\
 197 A keymap is a list (keymap . ALIST),\n\
 198 or a symbol whose function definition is itself a keymap.\n\
 199 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
 200 a vector of densely packed bindings for small character codes\n\
 201 is also allowed as an element.")
 202   (object)
 203      Lisp_Object object;
 204 {
 205   /* FIXME: Maybe this should return t for autoloaded keymaps?   -sm  */
 206   return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
 207 }
 208
 209 /* Check that OBJECT is a keymap (after dereferencing through any
 210    symbols).  If it is, return it.
 211
 212    If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
 213    is an autoload form, do the autoload and try again.
 214    If AUTOLOAD is nonzero, callers must assume GC is possible.
 215
 216    ERROR controls how we respond if OBJECT isn't a keymap.
 217    If ERROR is non-zero, signal an error; otherwise, just return Qnil.
 218
 219    Note that most of the time, we don't want to pursue autoloads.
 220    Functions like Faccessible_keymaps which scan entire keymap trees
 221    shouldn't load every autoloaded keymap.  I'm not sure about this,
 222    but it seems to me that only read_key_sequence, Flookup_key, and
 223    Fdefine_key should cause keymaps to be autoloaded.
 224
 225    This function can GC when AUTOLOAD is non-zero, because it calls
 226    do_autoload which can GC.  */
 227
 228 Lisp_Object
 229 get_keymap_1 (object, error, autoload)
 230      Lisp_Object object;
 231      int error, autoload;
 232 {
 233   Lisp_Object tem;
 234
 235  autoload_retry:
 236   if (NILP (object))
 237     goto end;
 238   if (CONSP (object) && EQ (XCAR (object), Qkeymap))
 239     return object;
 240   else
 241     {
 242       tem = indirect_function (object);
 243       if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
 244         return tem;
 245     }
 246
 247   /* Should we do an autoload?  Autoload forms for keymaps have
 248      Qkeymap as their fifth element.  */
 249   if (autoload
 250       && SYMBOLP (object)
 251       && CONSP (tem)
 252       && EQ (XCAR (tem), Qautoload))
 253     {
 254       Lisp_Object tail;
 255
 256       tail = Fnth (make_number (4), tem);
 257       if (EQ (tail, Qkeymap))
 258         {
 259           struct gcpro gcpro1, gcpro2;
 260
 261           GCPRO2 (tem, object);
 262           do_autoload (tem, object);
 263           UNGCPRO;
 264
 265           goto autoload_retry;
 266         }
 267     }
 268
 269  end:
 270   if (error)
 271     wrong_type_argument (Qkeymapp, object);
 272   else
 273     return Qnil;
 274 }
 275
 276
 277 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
 278    If OBJECT doesn't denote a keymap at all, signal an error.  */
 279 Lisp_Object
 280 get_keymap (object)
 281      Lisp_Object object;
 282 {
 283   return get_keymap_1 (object, 1, 0);
 284 }
 285 \f
 286 /* Return the parent map of the keymap MAP, or nil if it has none.
 287    We assume that MAP is a valid keymap.  */
 288
 289 DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
 290   "Return the parent keymap of KEYMAP.")
 291   (keymap)
 292      Lisp_Object keymap;
 293 {
 294   Lisp_Object list;
 295
 296   keymap = get_keymap_1 (keymap, 1, 1);
 297
 298   /* Skip past the initial element `keymap'.  */
 299   list = XCDR (keymap);
 300   for (; CONSP (list); list = XCDR (list))
 301     {
 302       /* See if there is another `keymap'.  */
 303       if (KEYMAPP (list))
 304         return list;
 305     }
 306
 307   return Qnil;
 308 }
 309
 310
 311 /* Set the parent keymap of MAP to PARENT.  */
 312
 313 DEFUN ("set-keymap-parent", Fset_keymap_parent, Sset_keymap_parent, 2, 2, 0,
 314   "Modify KEYMAP to set its parent map to PARENT.\n\
 315 PARENT should be nil or another keymap.")
 316   (keymap, parent)
 317      Lisp_Object keymap, parent;
 318 {
 319   Lisp_Object list, prev;
 320   struct gcpro gcpro1;
 321   int i;
 322
 323   keymap = get_keymap_1 (keymap, 1, 1);
 324   GCPRO1 (keymap);
 325
 326   if (!NILP (parent))
 327     {
 328       Lisp_Object k;
 329
 330       parent = get_keymap_1 (parent, 1, 1);
 331
 332       /* Check for cycles.  */
 333       k = parent;
 334       while (KEYMAPP (k) && !EQ (keymap, k))
 335         k = Fkeymap_parent (k);
 336       if (EQ (keymap, k))
 337         error ("Cyclic keymap inheritance");
 338     }
 339
 340   /* Skip past the initial element `keymap'.  */
 341   prev = keymap;
 342   while (1)
 343     {
 344       list = XCDR (prev);
 345       /* If there is a parent keymap here, replace it.
 346          If we came to the end, add the parent in PREV.  */
 347       if (! CONSP (list) || KEYMAPP (list))
 348         {
 349           /* If we already have the right parent, return now
 350              so that we avoid the loops below.  */
 351           if (EQ (XCDR (prev), parent))
 352             RETURN_UNGCPRO (parent);
 353
 354           XCDR (prev) = parent;
 355           break;
 356         }
 357       prev = list;
 358     }
 359
 360   /* Scan through for submaps, and set their parents too.  */
 361
 362   for (list = XCDR (keymap); CONSP (list); list = XCDR (list))
 363     {
 364       /* Stop the scan when we come to the parent.  */
 365       if (EQ (XCAR (list), Qkeymap))
 366         break;
 367
 368       /* If this element holds a prefix map, deal with it.  */
 369       if (CONSP (XCAR (list))
 370           && CONSP (XCDR (XCAR (list))))
 371         fix_submap_inheritance (keymap, XCAR (XCAR (list)),
 372                                 XCDR (XCAR (list)));
 373
 374       if (VECTORP (XCAR (list)))
 375         for (i = 0; i < XVECTOR (XCAR (list))->size; i++)
 376           if (CONSP (XVECTOR (XCAR (list))->contents[i]))
 377             fix_submap_inheritance (keymap, make_number (i),
 378                                     XVECTOR (XCAR (list))->contents[i]);
 379
 380       if (CHAR_TABLE_P (XCAR (list)))
 381         {
 382           Lisp_Object indices[3];
 383
 384           map_char_table (fix_submap_inheritance, Qnil, XCAR (list),
 385                           keymap, 0, indices);
 386         }
 387     }
 388
 389   RETURN_UNGCPRO (parent);
 390 }
 391
 392 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
 393    if EVENT is also a prefix in MAP's parent,
 394    make sure that SUBMAP inherits that definition as its own parent.  */
 395
 396 static void
 397 fix_submap_inheritance (map, event, submap)
 398      Lisp_Object map, event, submap;
 399 {
 400   Lisp_Object map_parent, parent_entry;
 401
 402   /* SUBMAP is a cons that we found as a key binding.
 403      Discard the other things found in a menu key binding.  */
 404
 405   if (CONSP (submap))
 406     {
 407       /* May be an old format menu item */
 408       if (STRINGP (XCAR (submap)))
 409         {
 410           submap = XCDR (submap);
 411           /* Also remove a menu help string, if any,
 412              following the menu item name.  */
 413           if (CONSP (submap) && STRINGP (XCAR (submap)))
 414             submap = XCDR (submap);
 415           /* Also remove the sublist that caches key equivalences, if any.  */
 416           if (CONSP (submap)
 417               && CONSP (XCAR (submap)))
 418             {
 419               Lisp_Object carcar;
 420               carcar = XCAR (XCAR (submap));
 421               if (NILP (carcar) || VECTORP (carcar))
 422                 submap = XCDR (submap);
 423             }
 424         }
 425
 426       /* Or a new format menu item */
 427       else if (EQ (XCAR (submap), Qmenu_item)
 428                && CONSP (XCDR (submap)))
 429         {
 430           submap = XCDR (XCDR (submap));
 431           if (CONSP (submap))
 432             submap = XCAR (submap);
 433         }
 434     }
 435
 436   /* If it isn't a keymap now, there's no work to do.  */
 437   if (! CONSP (submap)
 438       || ! EQ (XCAR (submap), Qkeymap))
 439     return;
 440
 441   map_parent = Fkeymap_parent (map);
 442   if (! NILP (map_parent))
 443     parent_entry = access_keymap (map_parent, event, 0, 0);
 444   else
 445     parent_entry = Qnil;
 446
 447   /* If MAP's parent has something other than a keymap,
 448      our own submap shadows it completely, so use nil as SUBMAP's parent.  */
 449   if (! (CONSP (parent_entry) && EQ (XCAR (parent_entry), Qkeymap)))
 450     parent_entry = Qnil;
 451
 452   if (! EQ (parent_entry, submap))
 453     {
 454       Lisp_Object submap_parent;
 455       submap_parent = submap;
 456       while (1)
 457         {
 458           Lisp_Object tem;
 459           tem = Fkeymap_parent (submap_parent);
 460           if (EQ (tem, parent_entry))
 461             return;
 462           if (CONSP (tem)
 463               && EQ (XCAR (tem), Qkeymap))
 464             submap_parent = tem;
 465           else
 466             break;
 467         }
 468       Fset_keymap_parent (submap_parent, parent_entry);
 469     }
 470 }
 471 \f
 472 /* Look up IDX in MAP.  IDX may be any sort of event.
 473    Note that this does only one level of lookup; IDX must be a single
 474    event, not a sequence.
 475
 476    If T_OK is non-zero, bindings for Qt are treated as default
 477    bindings; any key left unmentioned by other tables and bindings is
 478    given the binding of Qt.
 479
 480    If T_OK is zero, bindings for Qt are not treated specially.
 481
 482    If NOINHERIT, don't accept a subkeymap found in an inherited keymap.  */
 483
 484 Lisp_Object
 485 access_keymap (map, idx, t_ok, noinherit)
 486      Lisp_Object map;
 487      Lisp_Object idx;
 488      int t_ok;
 489      int noinherit;
 490 {
 491   int noprefix = 0;
 492   Lisp_Object val;
 493
 494   /* If idx is a list (some sort of mouse click, perhaps?),
 495      the index we want to use is the car of the list, which
 496      ought to be a symbol.  */
 497   idx = EVENT_HEAD (idx);
 498
 499   /* If idx is a symbol, it might have modifiers, which need to
 500      be put in the canonical order.  */
 501   if (SYMBOLP (idx))
 502     idx = reorder_modifiers (idx);
 503   else if (INTEGERP (idx))
 504     /* Clobber the high bits that can be present on a machine
 505        with more than 24 bits of integer.  */
 506     XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
 507
 508   {
 509     Lisp_Object tail;
 510     Lisp_Object t_binding;
 511
 512     t_binding = Qnil;
 513     for (tail = map; CONSP (tail); tail = XCDR (tail))
 514       {
 515         Lisp_Object binding;
 516
 517         binding = XCAR (tail);
 518         if (SYMBOLP (binding))
 519           {
 520             /* If NOINHERIT, stop finding prefix definitions
 521                after we pass a second occurrence of the `keymap' symbol.  */
 522             if (noinherit && EQ (binding, Qkeymap) && ! EQ (tail, map))
 523               noprefix = 1;
 524           }
 525         else if (CONSP (binding))
 526           {
 527             if (EQ (XCAR (binding), idx))
 528               {
 529                 val = XCDR (binding);
 530                 if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 531                   return Qnil;
 532                 if (CONSP (val))
 533                   fix_submap_inheritance (map, idx, val);
 534                 return val;
 535               }
 536             if (t_ok && EQ (XCAR (binding), Qt))
 537               t_binding = XCDR (binding);
 538           }
 539         else if (VECTORP (binding))
 540           {
 541             if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (binding)->size)
 542               {
 543                 val = XVECTOR (binding)->contents[XFASTINT (idx)];
 544                 if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 545                   return Qnil;
 546                 if (CONSP (val))
 547                   fix_submap_inheritance (map, idx, val);
 548                 return val;
 549               }
 550           }
 551         else if (CHAR_TABLE_P (binding))
 552           {
 553             /* Character codes with modifiers
 554                are not included in a char-table.
 555                All character codes without modifiers are included.  */
 556             if (NATNUMP (idx)
 557                 && ! (XFASTINT (idx)
 558                       & (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
 559                          | CHAR_SHIFT | CHAR_CTL | CHAR_META)))
 560               {
 561                 val = Faref (binding, idx);
 562                 if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))
 563                   return Qnil;
 564                 if (CONSP (val))
 565                   fix_submap_inheritance (map, idx, val);
 566                 return val;
 567               }
 568           }
 569
 570         QUIT;
 571       }
 572
 573     return t_binding;
 574   }
 575 }
 576
 577 /* Given OBJECT which was found in a slot in a keymap,
 578    trace indirect definitions to get the actual definition of that slot.
 579    An indirect definition is a list of the form
 580    (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
 581    and INDEX is the object to look up in KEYMAP to yield the definition.
 582
 583    Also if OBJECT has a menu string as the first element,
 584    remove that.  Also remove a menu help string as second element.
 585
 586    If AUTOLOAD is nonzero, load autoloadable keymaps
 587    that are referred to with indirection.  */
 588
 589 Lisp_Object
 590 get_keyelt (object, autoload)
 591      register Lisp_Object object;
 592      int autoload;
 593 {
 594   while (1)
 595     {
 596       if (!(CONSP (object)))
 597         /* This is really the value.  */
 598         return object;
 599
 600       /* If the keymap contents looks like (keymap ...) or (lambda ...)
 601          then use itself. */
 602       else if (EQ (XCAR (object), Qkeymap) || EQ (XCAR (object), Qlambda))
 603         return object;
 604
 605       /* If the keymap contents looks like (menu-item name . DEFN)
 606          or (menu-item name DEFN ...) then use DEFN.
 607          This is a new format menu item.  */
 608       else if (EQ (XCAR (object), Qmenu_item))
 609         {
 610           if (CONSP (XCDR (object)))
 611             {
 612               Lisp_Object tem;
 613
 614               object = XCDR (XCDR (object));
 615               tem = object;
 616               if (CONSP (object))
 617                 object = XCAR (object);
 618
 619               /* If there's a `:filter FILTER', apply FILTER to the
 620                  menu-item's definition to get the real definition to
 621                  use.  Temporarily inhibit GC while evaluating FILTER,
 622                  because not functions calling get_keyelt are prepared
 623                  for a GC.  */
 624               for (; CONSP (tem) && CONSP (XCDR (tem)); tem = XCDR (tem))
 625                 if (EQ (XCAR (tem), QCfilter))
 626                   {
 627                     int count = inhibit_garbage_collection ();
 628                     Lisp_Object filter;
 629                     filter = XCAR (XCDR (tem));
 630                     filter = list2 (filter, list2 (Qquote, object));
 631                     object = menu_item_eval_property (filter);
 632                     unbind_to (count, Qnil);
 633                     break;
 634                   }
 635             }
 636           else
 637             /* Invalid keymap */
 638             return object;
 639         }
 640
 641       /* If the keymap contents looks like (STRING . DEFN), use DEFN.
 642          Keymap alist elements like (CHAR MENUSTRING . DEFN)
 643          will be used by HierarKey menus.  */
 644       else if (STRINGP (XCAR (object)))
 645         {
 646           object = XCDR (object);
 647           /* Also remove a menu help string, if any,
 648              following the menu item name.  */
 649           if (CONSP (object) && STRINGP (XCAR (object)))
 650             object = XCDR (object);
 651           /* Also remove the sublist that caches key equivalences, if any.  */
 652           if (CONSP (object) && CONSP (XCAR (object)))
 653             {
 654               Lisp_Object carcar;
 655               carcar = XCAR (XCAR (object));
 656               if (NILP (carcar) || VECTORP (carcar))
 657                 object = XCDR (object);
 658             }
 659         }
 660
 661       /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
 662       else
 663         {
 664           Lisp_Object map;
 665
 666           map = get_keymap_1 (Fcar_safe (object), 0, autoload);
 667           if (NILP (map))
 668             /* Invalid keymap */
 669             return object;
 670           else
 671             {
 672               Lisp_Object key;
 673               key = Fcdr (object);
 674               if (INTEGERP (key) && (XUINT (key) & meta_modifier))
 675                 {
 676                   object = access_keymap (map, meta_prefix_char, 0, 0);
 677                   map = get_keymap_1 (object, 0, autoload);
 678                   object = access_keymap (map, make_number (XINT (key)
 679                                                             & ~meta_modifier),
 680                                           0, 0);
 681                 }
 682               else
 683                 object = access_keymap (map, key, 0, 0);
 684             }
 685         }
 686     }
 687 }
 688
 689 static Lisp_Object
 690 store_in_keymap (keymap, idx, def)
 691      Lisp_Object keymap;
 692      register Lisp_Object idx;
 693      register Lisp_Object def;
 694 {
 695   /* If we are preparing to dump, and DEF is a menu element
 696      with a menu item indicator, copy it to ensure it is not pure.  */
 697   if (CONSP (def) && PURE_P (def)
 698       && (EQ (XCAR (def), Qmenu_item) || STRINGP (XCAR (def))))
 699     def = Fcons (XCAR (def), XCDR (def));
 700
 701   if (!CONSP (keymap) || ! EQ (XCAR (keymap), Qkeymap))
 702     error ("attempt to define a key in a non-keymap");
 703
 704   /* If idx is a list (some sort of mouse click, perhaps?),
 705      the index we want to use is the car of the list, which
 706      ought to be a symbol.  */
 707   idx = EVENT_HEAD (idx);
 708
 709   /* If idx is a symbol, it might have modifiers, which need to
 710      be put in the canonical order.  */
 711   if (SYMBOLP (idx))
 712     idx = reorder_modifiers (idx);
 713   else if (INTEGERP (idx))
 714     /* Clobber the high bits that can be present on a machine
 715        with more than 24 bits of integer.  */
 716     XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
 717
 718   /* Scan the keymap for a binding of idx.  */
 719   {
 720     Lisp_Object tail;
 721
 722     /* The cons after which we should insert new bindings.  If the
 723        keymap has a table element, we record its position here, so new
 724        bindings will go after it; this way, the table will stay
 725        towards the front of the alist and character lookups in dense
 726        keymaps will remain fast.  Otherwise, this just points at the
 727        front of the keymap.  */
 728     Lisp_Object insertion_point;
 729
 730     insertion_point = keymap;
 731     for (tail = XCDR (keymap); CONSP (tail); tail = XCDR (tail))
 732       {
 733         Lisp_Object elt;
 734
 735         elt = XCAR (tail);
 736         if (VECTORP (elt))
 737           {
 738             if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)
 739               {
 740                 XVECTOR (elt)->contents[XFASTINT (idx)] = def;
 741                 return def;
 742               }
 743             insertion_point = tail;
 744           }
 745         else if (CHAR_TABLE_P (elt))
 746           {
 747             /* Character codes with modifiers
 748                are not included in a char-table.
 749                All character codes without modifiers are included.  */
 750             if (NATNUMP (idx)
 751                 && ! (XFASTINT (idx)
 752                       & (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
 753                          | CHAR_SHIFT | CHAR_CTL | CHAR_META)))
 754               {
 755                 Faset (elt, idx, def);
 756                 return def;
 757               }
 758             insertion_point = tail;
 759           }
 760         else if (CONSP (elt))
 761           {
 762             if (EQ (idx, XCAR (elt)))
 763               {
 764                 XCDR (elt) = def;
 765                 return def;
 766               }
 767           }
 768         else if (SYMBOLP (elt))
 769           {
 770             /* If we find a 'keymap' symbol in the spine of KEYMAP,
 771                then we must have found the start of a second keymap
 772                being used as the tail of KEYMAP, and a binding for IDX
 773                should be inserted before it.  */
 774             if (EQ (elt, Qkeymap))
 775               goto keymap_end;
 776           }
 777
 778         QUIT;
 779       }
 780
 781   keymap_end:
 782     /* We have scanned the entire keymap, and not found a binding for
 783        IDX.  Let's add one.  */
 784     XCDR (insertion_point)
 785       = Fcons (Fcons (idx, def), XCDR (insertion_point));
 786   }
 787
 788   return def;
 789 }
 790
 791 void
 792 copy_keymap_1 (chartable, idx, elt)
 793      Lisp_Object chartable, idx, elt;
 794 {
 795   if (!SYMBOLP (elt) && ! NILP (Fkeymapp (elt)))
 796     Faset (chartable, idx, Fcopy_keymap (elt));
 797 }
 798
 799 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
 800   "Return a copy of the keymap KEYMAP.\n\
 801 The copy starts out with the same definitions of KEYMAP,\n\
 802 but changing either the copy or KEYMAP does not affect the other.\n\
 803 Any key definitions that are subkeymaps are recursively copied.\n\
 804 However, a key definition which is a symbol whose definition is a keymap\n\
 805 is not copied.")
 806   (keymap)
 807      Lisp_Object keymap;
 808 {
 809   register Lisp_Object copy, tail;
 810
 811   copy = Fcopy_alist (get_keymap (keymap));
 812
 813   for (tail = copy; CONSP (tail); tail = XCDR (tail))
 814     {
 815       Lisp_Object elt;
 816
 817       elt = XCAR (tail);
 818       if (CHAR_TABLE_P (elt))
 819         {
 820           Lisp_Object indices[3];
 821
 822           elt = Fcopy_sequence (elt);
 823           XCAR (tail) = elt;
 824
 825           map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
 826         }
 827       else if (VECTORP (elt))
 828         {
 829           int i;
 830
 831           elt = Fcopy_sequence (elt);
 832           XCAR (tail) = elt;
 833
 834           for (i = 0; i < XVECTOR (elt)->size; i++)
 835             if (!SYMBOLP (XVECTOR (elt)->contents[i])
 836                 && ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
 837               XVECTOR (elt)->contents[i]
 838                 = Fcopy_keymap (XVECTOR (elt)->contents[i]);
 839         }
 840       else if (CONSP (elt) && CONSP (XCDR (elt)))
 841         {
 842           Lisp_Object tem;
 843           tem = XCDR (elt);
 844
 845           /* Is this a new format menu item.  */
 846           if (EQ (XCAR (tem),Qmenu_item))
 847             {
 848               /* Copy cell with menu-item marker.  */
 849               XCDR (elt)
 850                 = Fcons (XCAR (tem), XCDR (tem));
 851               elt = XCDR (elt);
 852               tem = XCDR (elt);
 853               if (CONSP (tem))
 854                 {
 855                   /* Copy cell with menu-item name.  */
 856                   XCDR (elt)
 857                     = Fcons (XCAR (tem), XCDR (tem));
 858                   elt = XCDR (elt);
 859                   tem = XCDR (elt);
 860                 };
 861               if (CONSP (tem))
 862                 {
 863                   /* Copy cell with binding and if the binding is a keymap,
 864                      copy that.  */
 865                   XCDR (elt)
 866                     = Fcons (XCAR (tem), XCDR (tem));
 867                   elt = XCDR (elt);
 868                   tem = XCAR (elt);
 869                   if (!(SYMBOLP (tem) || NILP (Fkeymapp (tem))))
 870                     XCAR (elt) = Fcopy_keymap (tem);
 871                   tem = XCDR (elt);
 872                   if (CONSP (tem) && CONSP (XCAR (tem)))
 873                     /* Delete cache for key equivalences.  */
 874                     XCDR (elt) = XCDR (tem);
 875                 }
 876             }
 877           else
 878             {
 879               /* It may be an old fomat menu item.
 880                  Skip the optional menu string.
 881               */
 882               if (STRINGP (XCAR (tem)))
 883                 {
 884                   /* Copy the cell, since copy-alist didn't go this deep.  */
 885                   XCDR (elt)
 886                     = Fcons (XCAR (tem), XCDR (tem));
 887                   elt = XCDR (elt);
 888                   tem = XCDR (elt);
 889                   /* Also skip the optional menu help string.  */
 890                   if (CONSP (tem) && STRINGP (XCAR (tem)))
 891                     {
 892                       XCDR (elt)
 893                         = Fcons (XCAR (tem), XCDR (tem));
 894                       elt = XCDR (elt);
 895                       tem = XCDR (elt);
 896                     }
 897                   /* There may also be a list that caches key equivalences.
 898                      Just delete it for the new keymap.  */
 899                   if (CONSP (tem)
 900                       && CONSP (XCAR (tem))
 901                       && (NILP (XCAR (XCAR (tem)))
 902                           || VECTORP (XCAR (XCAR (tem)))))
 903                     XCDR (elt) = XCDR (tem);
 904                 }
 905               if (CONSP (elt)
 906                   && ! SYMBOLP (XCDR (elt))
 907                   && ! NILP (Fkeymapp (XCDR (elt))))
 908                 XCDR (elt) = Fcopy_keymap (XCDR (elt));
 909             }
 910
 911         }
 912     }
 913
 914   return copy;
 915 }
 916 \f
 917 /* Simple Keymap mutators and accessors.                                */
 918
 919 /* GC is possible in this function if it autoloads a keymap.  */
 920
 921 DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
 922   "Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.\n\
 923 KEYMAP is a keymap.  KEY is a string or a vector of symbols and characters\n\
 924 meaning a sequence of keystrokes and events.\n\
 925 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
 926 can be included if you use a vector.\n\
 927 DEF is anything that can be a key's definition:\n\
 928  nil (means key is undefined in this keymap),\n\
 929  a command (a Lisp function suitable for interactive calling)\n\
 930  a string (treated as a keyboard macro),\n\
 931  a keymap (to define a prefix key),\n\
 932  a symbol.  When the key is looked up, the symbol will stand for its\n\
 933     function definition, which should at that time be one of the above,\n\
 934     or another symbol whose function definition is used, etc.\n\
 935  a cons (STRING . DEFN), meaning that DEFN is the definition\n\
 936     (DEFN should be a valid definition in its own right),\n\
 937  or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
 938 \n\
 939 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
 940 the front of KEYMAP.")
 941   (keymap, key, def)
 942      Lisp_Object keymap;
 943      Lisp_Object key;
 944      Lisp_Object def;
 945 {
 946   register int idx;
 947   register Lisp_Object c;
 948   register Lisp_Object cmd;
 949   int metized = 0;
 950   int meta_bit;
 951   int length;
 952   struct gcpro gcpro1, gcpro2, gcpro3;
 953
 954   keymap = get_keymap_1 (keymap, 1, 1);
 955
 956   if (!VECTORP (key) && !STRINGP (key))
 957     key = wrong_type_argument (Qarrayp, key);
 958
 959   length = XFASTINT (Flength (key));
 960   if (length == 0)
 961     return Qnil;
 962
 963   if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
 964     Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);
 965
 966   GCPRO3 (keymap, key, def);
 967
 968   if (VECTORP (key))
 969     meta_bit = meta_modifier;
 970   else
 971     meta_bit = 0x80;
 972
 973   idx = 0;
 974   while (1)
 975     {
 976       c = Faref (key, make_number (idx));
 977
 978       if (CONSP (c) && lucid_event_type_list_p (c))
 979         c = Fevent_convert_list (c);
 980
 981       if (INTEGERP (c)
 982           && (XINT (c) & meta_bit)
 983           && !metized)
 984         {
 985           c = meta_prefix_char;
 986           metized = 1;
 987         }
 988       else
 989         {
 990           if (INTEGERP (c))
 991             XSETINT (c, XINT (c) & ~meta_bit);
 992
 993           metized = 0;
 994           idx++;
 995         }
 996
 997       if (! INTEGERP (c) && ! SYMBOLP (c) && ! CONSP (c))
 998         error ("Key sequence contains invalid events");
 999
1000       if (idx == length)
1001         RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
1002
1003       cmd = get_keyelt (access_keymap (keymap, c, 0, 1), 1);
1004
1005       /* If this key is undefined, make it a prefix.  */
1006       if (NILP (cmd))
1007         cmd = define_as_prefix (keymap, c);
1008
1009       keymap = get_keymap_1 (cmd, 0, 1);
1010       if (NILP (keymap))
1011         /* We must use Fkey_description rather than just passing key to
1012            error; key might be a vector, not a string.  */
1013         error ("Key sequence %s uses invalid prefix characters",
1014                XSTRING (Fkey_description (key))->data);
1015     }
1016 }
1017
1018 /* Value is number if KEY is too long; NIL if valid but has no definition. */
1019 /* GC is possible in this function if it autoloads a keymap.  */
1020
1021 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
1022   "In keymap KEYMAP, look up key sequence KEY.  Return the definition.\n\
1023 nil means undefined.  See doc of `define-key' for kinds of definitions.\n\
1024 \n\
1025 A number as value means KEY is \"too long\";\n\
1026 that is, characters or symbols in it except for the last one\n\
1027 fail to be a valid sequence of prefix characters in KEYMAP.\n\
1028 The number is how many characters at the front of KEY\n\
1029 it takes to reach a non-prefix command.\n\
1030 \n\
1031 Normally, `lookup-key' ignores bindings for t, which act as default\n\
1032 bindings, used when nothing else in the keymap applies; this makes it\n\
1033 usable as a general function for probing keymaps.  However, if the\n\
1034 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
1035 recognize the default bindings, just as `read-key-sequence' does.")
1036   (keymap, key, accept_default)
1037      register Lisp_Object keymap;
1038      Lisp_Object key;
1039      Lisp_Object accept_default;
1040 {
1041   register int idx;
1042   register Lisp_Object cmd;
1043   register Lisp_Object c;
1044   int metized = 0;
1045   int length;
1046   int t_ok = ! NILP (accept_default);
1047   int meta_bit;
1048   struct gcpro gcpro1;
1049
1050   keymap = get_keymap_1 (keymap, 1, 1);
1051
1052   if (!VECTORP (key) && !STRINGP (key))
1053     key = wrong_type_argument (Qarrayp, key);
1054
1055   length = XFASTINT (Flength (key));
1056   if (length == 0)
1057     return keymap;
1058
1059   if (VECTORP (key))
1060     meta_bit = meta_modifier;
1061   else
1062     meta_bit = 0x80;
1063
1064   GCPRO1 (key);
1065
1066   idx = 0;
1067   while (1)
1068     {
1069       c = Faref (key, make_number (idx));
1070
1071       if (CONSP (c) && lucid_event_type_list_p (c))
1072         c = Fevent_convert_list (c);
1073
1074       if (INTEGERP (c)
1075           && (XINT (c) & meta_bit)
1076           && !metized)
1077         {
1078           c = meta_prefix_char;
1079           metized = 1;
1080         }
1081       else
1082         {
1083           if (INTEGERP (c))
1084             XSETINT (c, XINT (c) & ~meta_bit);
1085
1086           metized = 0;
1087           idx++;
1088         }
1089
1090       cmd = get_keyelt (access_keymap (keymap, c, t_ok, 0), 1);
1091       if (idx == length)
1092         RETURN_UNGCPRO (cmd);
1093
1094       keymap = get_keymap_1 (cmd, 0, 1);
1095       if (NILP (keymap))
1096         RETURN_UNGCPRO (make_number (idx));
1097
1098       QUIT;
1099     }
1100 }
1101
1102 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1103    Assume that currently it does not define C at all.
1104    Return the keymap.  */
1105
1106 static Lisp_Object
1107 define_as_prefix (keymap, c)
1108      Lisp_Object keymap, c;
1109 {
1110   Lisp_Object inherit, cmd;
1111
1112   cmd = Fmake_sparse_keymap (Qnil);
1113   /* If this key is defined as a prefix in an inherited keymap,
1114      make it a prefix in this map, and make its definition
1115      inherit the other prefix definition.  */
1116   inherit = access_keymap (keymap, c, 0, 0);
1117 #if 0
1118   /* This code is needed to do the right thing in the following case:
1119      keymap A inherits from B,
1120      you define KEY as a prefix in A,
1121      then later you define KEY as a prefix in B.
1122      We want the old prefix definition in A to inherit from that in B.
1123      It is hard to do that retroactively, so this code
1124      creates the prefix in B right away.
1125
1126      But it turns out that this code causes problems immediately
1127      when the prefix in A is defined: it causes B to define KEY
1128      as a prefix with no subcommands.
1129
1130      So I took out this code.  */
1131   if (NILP (inherit))
1132     {
1133       /* If there's an inherited keymap
1134          and it doesn't define this key,
1135          make it define this key.  */
1136       Lisp_Object tail;
1137
1138       for (tail = Fcdr (keymap); CONSP (tail); tail = XCDR (tail))
1139         if (EQ (XCAR (tail), Qkeymap))
1140           break;
1141
1142       if (!NILP (tail))
1143         inherit = define_as_prefix (tail, c);
1144     }
1145 #endif
1146
1147   cmd = nconc2 (cmd, inherit);
1148   store_in_keymap (keymap, c, cmd);
1149
1150   return cmd;
1151 }
1152
1153 /* Append a key to the end of a key sequence.  We always make a vector.  */
1154
1155 Lisp_Object
1156 append_key (key_sequence, key)
1157      Lisp_Object key_sequence, key;
1158 {
1159   Lisp_Object args[2];
1160
1161   args[0] = key_sequence;
1162
1163   args[1] = Fcons (key, Qnil);
1164   return Fvconcat (2, args);
1165 }
1166
1167 \f
1168 /* Global, local, and minor mode keymap stuff.                          */
1169
1170 /* We can't put these variables inside current_minor_maps, since under
1171    some systems, static gets macro-defined to be the empty string.
1172    Ickypoo.  */
1173 static Lisp_Object *cmm_modes, *cmm_maps;
1174 static int cmm_size;
1175
1176 /* Error handler used in current_minor_maps.  */
1177 static Lisp_Object
1178 current_minor_maps_error ()
1179 {
1180   return Qnil;
1181 }
1182
1183 /* Store a pointer to an array of the keymaps of the currently active
1184    minor modes in *buf, and return the number of maps it contains.
1185
1186    This function always returns a pointer to the same buffer, and may
1187    free or reallocate it, so if you want to keep it for a long time or
1188    hand it out to lisp code, copy it.  This procedure will be called
1189    for every key sequence read, so the nice lispy approach (return a
1190    new assoclist, list, what have you) for each invocation would
1191    result in a lot of consing over time.
1192
1193    If we used xrealloc/xmalloc and ran out of memory, they would throw
1194    back to the command loop, which would try to read a key sequence,
1195    which would call this function again, resulting in an infinite
1196    loop.  Instead, we'll use realloc/malloc and silently truncate the
1197    list, let the key sequence be read, and hope some other piece of
1198    code signals the error.  */
1199 int
1200 current_minor_maps (modeptr, mapptr)
1201      Lisp_Object **modeptr, **mapptr;
1202 {
1203   int i = 0;
1204   int list_number = 0;
1205   Lisp_Object alist, assoc, var, val;
1206   Lisp_Object lists[2];
1207
1208   lists[0] = Vminor_mode_overriding_map_alist;
1209   lists[1] = Vminor_mode_map_alist;
1210
1211   for (list_number = 0; list_number < 2; list_number++)
1212     for (alist = lists[list_number];
1213          CONSP (alist);
1214          alist = XCDR (alist))
1215       if ((assoc = XCAR (alist), CONSP (assoc))
1216           && (var = XCAR (assoc), SYMBOLP (var))
1217           && (val = find_symbol_value (var), ! EQ (val, Qunbound))
1218           && ! NILP (val))
1219         {
1220           Lisp_Object temp;
1221
1222           /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1223              and also an entry in Vminor_mode_map_alist,
1224              ignore the latter.  */
1225           if (list_number == 1)
1226             {
1227               val = assq_no_quit (var, lists[0]);
1228               if (!NILP (val))
1229                 break;
1230             }
1231
1232           if (i >= cmm_size)
1233             {
1234               Lisp_Object *newmodes, *newmaps;
1235
1236               if (cmm_maps)
1237                 {
1238                   BLOCK_INPUT;
1239                   cmm_size *= 2;
1240                   newmodes
1241                     = (Lisp_Object *) realloc (cmm_modes,
1242                                                cmm_size * sizeof (Lisp_Object));
1243                   newmaps
1244                     = (Lisp_Object *) realloc (cmm_maps,
1245                                                cmm_size * sizeof (Lisp_Object));
1246                   UNBLOCK_INPUT;
1247                 }
1248               else
1249                 {
1250                   BLOCK_INPUT;
1251                   cmm_size = 30;
1252                   newmodes
1253                     = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
1254                   newmaps
1255                     = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
1256                   UNBLOCK_INPUT;
1257                 }
1258
1259               if (newmaps && newmodes)
1260                 {
1261                   cmm_modes = newmodes;
1262                   cmm_maps = newmaps;
1263                 }
1264               else
1265                 break;
1266             }
1267
1268           /* Get the keymap definition--or nil if it is not defined.  */
1269           temp = internal_condition_case_1 (Findirect_function,
1270                                             XCDR (assoc),
1271                                             Qerror, current_minor_maps_error);
1272           if (!NILP (temp))
1273             {
1274               cmm_modes[i] = var;
1275               cmm_maps [i] = temp;
1276               i++;
1277             }
1278         }
1279
1280   if (modeptr) *modeptr = cmm_modes;
1281   if (mapptr)  *mapptr  = cmm_maps;
1282   return i;
1283 }
1284
1285 /* GC is possible in this function if it autoloads a keymap.  */
1286
1287 DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
1288   "Return the binding for command KEY in current keymaps.\n\
1289 KEY is a string or vector, a sequence of keystrokes.\n\
1290 The binding is probably a symbol with a function definition.\n\
1291 \n\
1292 Normally, `key-binding' ignores bindings for t, which act as default\n\
1293 bindings, used when nothing else in the keymap applies; this makes it\n\
1294 usable as a general function for probing keymaps.  However, if the\n\
1295 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1296 recognize the default bindings, just as `read-key-sequence' does.")
1297   (key, accept_default)
1298      Lisp_Object key, accept_default;
1299 {
1300   Lisp_Object *maps, value;
1301   int nmaps, i;
1302   struct gcpro gcpro1;
1303
1304   GCPRO1 (key);
1305
1306   if (!NILP (current_kboard->Voverriding_terminal_local_map))
1307     {
1308       value = Flookup_key (current_kboard->Voverriding_terminal_local_map,
1309                            key, accept_default);
1310       if (! NILP (value) && !INTEGERP (value))
1311         RETURN_UNGCPRO (value);
1312     }
1313   else if (!NILP (Voverriding_local_map))
1314     {
1315       value = Flookup_key (Voverriding_local_map, key, accept_default);
1316       if (! NILP (value) && !INTEGERP (value))
1317         RETURN_UNGCPRO (value);
1318     }
1319   else
1320     {
1321       Lisp_Object local;
1322
1323       nmaps = current_minor_maps (0, &maps);
1324       /* Note that all these maps are GCPRO'd
1325          in the places where we found them.  */
1326
1327       for (i = 0; i < nmaps; i++)
1328         if (! NILP (maps[i]))
1329           {
1330             value = Flookup_key (maps[i], key, accept_default);
1331             if (! NILP (value) && !INTEGERP (value))
1332               RETURN_UNGCPRO (value);
1333           }
1334
1335       local = get_local_map (PT, current_buffer, keymap);
1336       if (! NILP (local))
1337         {
1338           value = Flookup_key (local, key, accept_default);
1339           if (! NILP (value) && !INTEGERP (value))
1340             RETURN_UNGCPRO (value);
1341         }
1342
1343       local = get_local_map (PT, current_buffer, local_map);
1344
1345       if (! NILP (local))
1346         {
1347           value = Flookup_key (local, key, accept_default);
1348           if (! NILP (value) && !INTEGERP (value))
1349             RETURN_UNGCPRO (value);
1350         }
1351     }
1352
1353   value = Flookup_key (current_global_map, key, accept_default);
1354   UNGCPRO;
1355   if (! NILP (value) && !INTEGERP (value))
1356     return value;
1357
1358   return Qnil;
1359 }
1360
1361 /* GC is possible in this function if it autoloads a keymap.  */
1362
1363 DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
1364   "Return the binding for command KEYS in current local keymap only.\n\
1365 KEYS is a string, a sequence of keystrokes.\n\
1366 The binding is probably a symbol with a function definition.\n\
1367 \n\
1368 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1369 bindings; see the description of `lookup-key' for more details about this.")
1370   (keys, accept_default)
1371      Lisp_Object keys, accept_default;
1372 {
1373   register Lisp_Object map;
1374   map = current_buffer->keymap;
1375   if (NILP (map))
1376     return Qnil;
1377   return Flookup_key (map, keys, accept_default);
1378 }
1379
1380 /* GC is possible in this function if it autoloads a keymap.  */
1381
1382 DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
1383   "Return the binding for command KEYS in current global keymap only.\n\
1384 KEYS is a string, a sequence of keystrokes.\n\
1385 The binding is probably a symbol with a function definition.\n\
1386 This function's return values are the same as those of lookup-key\n\
1387 \(which see).\n\
1388 \n\
1389 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1390 bindings; see the description of `lookup-key' for more details about this.")
1391   (keys, accept_default)
1392      Lisp_Object keys, accept_default;
1393 {
1394   return Flookup_key (current_global_map, keys, accept_default);
1395 }
1396
1397 /* GC is possible in this function if it autoloads a keymap.  */
1398
1399 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
1400   "Find the visible minor mode bindings of KEY.\n\
1401 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1402 the symbol which names the minor mode binding KEY, and BINDING is\n\
1403 KEY's definition in that mode.  In particular, if KEY has no\n\
1404 minor-mode bindings, return nil.  If the first binding is a\n\
1405 non-prefix, all subsequent bindings will be omitted, since they would\n\
1406 be ignored.  Similarly, the list doesn't include non-prefix bindings\n\
1407 that come after prefix bindings.\n\
1408 \n\
1409 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1410 bindings; see the description of `lookup-key' for more details about this.")
1411   (key, accept_default)
1412      Lisp_Object key, accept_default;
1413 {
1414   Lisp_Object *modes, *maps;
1415   int nmaps;
1416   Lisp_Object binding;
1417   int i, j;
1418   struct gcpro gcpro1, gcpro2;
1419
1420   nmaps = current_minor_maps (&modes, &maps);
1421   /* Note that all these maps are GCPRO'd
1422      in the places where we found them.  */
1423
1424   binding = Qnil;
1425   GCPRO2 (key, binding);
1426
1427   for (i = j = 0; i < nmaps; i++)
1428     if (! NILP (maps[i])
1429         && ! NILP (binding = Flookup_key (maps[i], key, accept_default))
1430         && !INTEGERP (binding))
1431       {
1432         if (! NILP (get_keymap (binding)))
1433           maps[j++] = Fcons (modes[i], binding);
1434         else if (j == 0)
1435           RETURN_UNGCPRO (Fcons (Fcons (modes[i], binding), Qnil));
1436       }
1437
1438   UNGCPRO;
1439   return Flist (j, maps);
1440 }
1441
1442 DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 3, 0,
1443   "Define COMMAND as a prefix command.  COMMAND should be a symbol.\n\
1444 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1445 If a second optional argument MAPVAR is given, the map is stored as\n\
1446 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1447 as a function.\n\
1448 The third optional argument NAME, if given, supplies a menu name\n\
1449 string for the map.  This is required to use the keymap as a menu.")
1450   (command, mapvar, name)
1451      Lisp_Object command, mapvar, name;
1452 {
1453   Lisp_Object map;
1454   map = Fmake_sparse_keymap (name);
1455   Ffset (command, map);
1456   if (!NILP (mapvar))
1457     Fset (mapvar, map);
1458   else
1459     Fset (command, map);
1460   return command;
1461 }
1462
1463 DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0,
1464   "Select KEYMAP as the global keymap.")
1465   (keymap)
1466      Lisp_Object keymap;
1467 {
1468   keymap = get_keymap (keymap);
1469   current_global_map = keymap;
1470
1471   return Qnil;
1472 }
1473
1474 DEFUN ("use-local-map", Fuse_local_map, Suse_local_map, 1, 1, 0,
1475   "Select KEYMAP as the local keymap.\n\
1476 If KEYMAP is nil, that means no local keymap.")
1477   (keymap)
1478      Lisp_Object keymap;
1479 {
1480   if (!NILP (keymap))
1481     keymap = get_keymap (keymap);
1482
1483   current_buffer->keymap = keymap;
1484
1485   return Qnil;
1486 }
1487
1488 DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 0, 0,
1489   "Return current buffer's local keymap, or nil if it has none.")
1490   ()
1491 {
1492   return current_buffer->keymap;
1493 }
1494
1495 DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0,
1496   "Return the current global keymap.")
1497   ()
1498 {
1499   return current_global_map;
1500 }
1501
1502 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_maps, 0, 0, 0,
1503   "Return a list of keymaps for the minor modes of the current buffer.")
1504   ()
1505 {
1506   Lisp_Object *maps;
1507   int nmaps = current_minor_maps (0, &maps);
1508
1509   return Flist (nmaps, maps);
1510 }
1511 \f
1512 /* Help functions for describing and documenting keymaps.               */
1513
1514 static void accessible_keymaps_char_table ();
1515
1516 /* This function cannot GC.  */
1517
1518 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
1519   1, 2, 0,
1520   "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1521 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1522 KEYS starting from KEYMAP gets you to MAP.  These elements are ordered\n\
1523 so that the KEYS increase in length.  The first element is ([] . KEYMAP).\n\
1524 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1525 then the value includes only maps for prefixes that start with PREFIX.")
1526   (keymap, prefix)
1527      Lisp_Object keymap, prefix;
1528 {
1529   Lisp_Object maps, good_maps, tail;
1530   int prefixlen = 0;
1531
1532   /* no need for gcpro because we don't autoload any keymaps.  */
1533
1534   if (!NILP (prefix))
1535     prefixlen = XINT (Flength (prefix));
1536
1537   if (!NILP (prefix))
1538     {
1539       /* If a prefix was specified, start with the keymap (if any) for
1540          that prefix, so we don't waste time considering other prefixes.  */
1541       Lisp_Object tem;
1542       tem = Flookup_key (keymap, prefix, Qt);
1543       /* Flookup_key may give us nil, or a number,
1544          if the prefix is not defined in this particular map.
1545          It might even give us a list that isn't a keymap.  */
1546       tem = get_keymap_1 (tem, 0, 0);
1547       if (!NILP (tem))
1548         {
1549           /* Convert PREFIX to a vector now, so that later on
1550              we don't have to deal with the possibility of a string.  */
1551           if (STRINGP (prefix))
1552             {
1553               int i, i_byte, c;
1554               Lisp_Object copy;
1555
1556               copy = Fmake_vector (make_number (XSTRING (prefix)->size), Qnil);
1557               for (i = 0, i_byte = 0; i < XSTRING (prefix)->size;)
1558                 {
1559                   int i_before = i;
1560
1561                   FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
1562                   if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
1563                     c ^= 0200 | meta_modifier;
1564                   XVECTOR (copy)->contents[i_before] = make_number (c);
1565                 }
1566               prefix = copy;
1567             }
1568           maps = Fcons (Fcons (prefix, tem), Qnil);
1569         }
1570       else
1571         return Qnil;
1572     }
1573   else
1574     maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
1575                          get_keymap (keymap)),
1576                   Qnil);
1577
1578   /* For each map in the list maps,
1579      look at any other maps it points to,
1580      and stick them at the end if they are not already in the list.
1581
1582      This is a breadth-first traversal, where tail is the queue of
1583      nodes, and maps accumulates a list of all nodes visited.  */
1584
1585   for (tail = maps; CONSP (tail); tail = XCDR (tail))
1586     {
1587       register Lisp_Object thisseq, thismap;
1588       Lisp_Object last;
1589       /* Does the current sequence end in the meta-prefix-char?  */
1590       int is_metized;
1591
1592       thisseq = Fcar (Fcar (tail));
1593       thismap = Fcdr (Fcar (tail));
1594       last = make_number (XINT (Flength (thisseq)) - 1);
1595       is_metized = (XINT (last) >= 0
1596                     /* Don't metize the last char of PREFIX.  */
1597                     && XINT (last) >= prefixlen
1598                     && EQ (Faref (thisseq, last), meta_prefix_char));
1599
1600       for (; CONSP (thismap); thismap = XCDR (thismap))
1601         {
1602           Lisp_Object elt;
1603
1604           elt = XCAR (thismap);
1605
1606           QUIT;
1607
1608           if (CHAR_TABLE_P (elt))
1609             {
1610               Lisp_Object indices[3];
1611
1612               map_char_table (accessible_keymaps_char_table, Qnil,
1613                               elt, Fcons (maps, Fcons (tail, thisseq)),
1614                               0, indices);
1615             }
1616           else if (VECTORP (elt))
1617             {
1618               register int i;
1619
1620               /* Vector keymap.  Scan all the elements.  */
1621               for (i = 0; i < XVECTOR (elt)->size; i++)
1622                 {
1623                   register Lisp_Object tem;
1624                   register Lisp_Object cmd;
1625
1626                   cmd = get_keyelt (XVECTOR (elt)->contents[i], 0);
1627                   if (NILP (cmd)) continue;
1628                   tem = Fkeymapp (cmd);
1629                   if (!NILP (tem))
1630                     {
1631                       cmd = get_keymap (cmd);
1632                       /* Ignore keymaps that are already added to maps.  */
1633                       tem = Frassq (cmd, maps);
1634                       if (NILP (tem))
1635                         {
1636                           /* If the last key in thisseq is meta-prefix-char,
1637                              turn it into a meta-ized keystroke.  We know
1638                              that the event we're about to append is an
1639                              ascii keystroke since we're processing a
1640                              keymap table.  */
1641                           if (is_metized)
1642                             {
1643                               int meta_bit = meta_modifier;
1644                               tem = Fcopy_sequence (thisseq);
1645
1646                               Faset (tem, last, make_number (i | meta_bit));
1647
1648                               /* This new sequence is the same length as
1649                                  thisseq, so stick it in the list right
1650                                  after this one.  */
1651                               XCDR (tail)
1652                                 = Fcons (Fcons (tem, cmd), XCDR (tail));
1653                             }
1654                           else
1655                             {
1656                               tem = append_key (thisseq, make_number (i));
1657                               nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
1658                             }
1659                         }
1660                     }
1661                 }
1662             }
1663           else if (CONSP (elt))
1664             {
1665               register Lisp_Object cmd, tem;
1666
1667               cmd = get_keyelt (XCDR (elt), 0);
1668               /* Ignore definitions that aren't keymaps themselves.  */
1669               tem = Fkeymapp (cmd);
1670               if (!NILP (tem))
1671                 {
1672                   /* Ignore keymaps that have been seen already.  */
1673                   cmd = get_keymap (cmd);
1674                   tem = Frassq (cmd, maps);
1675                   if (NILP (tem))
1676                     {
1677                       /* Let elt be the event defined by this map entry.  */
1678                       elt = XCAR (elt);
1679
1680                       /* If the last key in thisseq is meta-prefix-char, and
1681                          this entry is a binding for an ascii keystroke,
1682                          turn it into a meta-ized keystroke.  */
1683                       if (is_metized && INTEGERP (elt))
1684                         {
1685                           Lisp_Object element;
1686
1687                           element = thisseq;
1688                           tem = Fvconcat (1, &element);
1689                           XSETFASTINT (XVECTOR (tem)->contents[XINT (last)],
1690                                        XINT (elt) | meta_modifier);
1691
1692                           /* This new sequence is the same length as
1693                              thisseq, so stick it in the list right
1694                              after this one.  */
1695                           XCDR (tail)
1696                             = Fcons (Fcons (tem, cmd), XCDR (tail));
1697                         }
1698                       else
1699                         nconc2 (tail,
1700                                 Fcons (Fcons (append_key (thisseq, elt), cmd),
1701                                        Qnil));
1702                     }
1703                 }
1704             }
1705         }
1706     }
1707
1708   if (NILP (prefix))
1709     return maps;
1710
1711   /* Now find just the maps whose access prefixes start with PREFIX.  */
1712
1713   good_maps = Qnil;
1714   for (; CONSP (maps); maps = XCDR (maps))
1715     {
1716       Lisp_Object elt, thisseq;
1717       elt = XCAR (maps);
1718       thisseq = XCAR (elt);
1719       /* The access prefix must be at least as long as PREFIX,
1720          and the first elements must match those of PREFIX.  */
1721       if (XINT (Flength (thisseq)) >= prefixlen)
1722         {
1723           int i;
1724           for (i = 0; i < prefixlen; i++)
1725             {
1726               Lisp_Object i1;
1727               XSETFASTINT (i1, i);
1728               if (!EQ (Faref (thisseq, i1), Faref (prefix, i1)))
1729                 break;
1730             }
1731           if (i == prefixlen)
1732             good_maps = Fcons (elt, good_maps);
1733         }
1734     }
1735
1736   return Fnreverse (good_maps);
1737 }
1738
1739 static void
1740 accessible_keymaps_char_table (args, index, cmd)
1741      Lisp_Object args, index, cmd;
1742 {
1743   Lisp_Object tem;
1744   Lisp_Object maps, tail, thisseq;
1745
1746   if (NILP (cmd))
1747     return;
1748
1749   maps = XCAR (args);
1750   tail = XCAR (XCDR (args));
1751   thisseq = XCDR (XCDR (args));
1752
1753   tem = Fkeymapp (cmd);
1754   if (!NILP (tem))
1755     {
1756       cmd = get_keymap (cmd);
1757       /* Ignore keymaps that are already added to maps.  */
1758       tem = Frassq (cmd, maps);
1759       if (NILP (tem))
1760         {
1761           tem = append_key (thisseq, index);
1762           nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
1763         }
1764     }
1765 }
1766 \f
1767 Lisp_Object Qsingle_key_description, Qkey_description;
1768
1769 /* This function cannot GC.  */
1770
1771 DEFUN ("key-description", Fkey_description, Skey_description, 1, 1, 0,
1772   "Return a pretty description of key-sequence KEYS.\n\
1773 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1774 spaces are put between sequence elements, etc.")
1775   (keys)
1776      Lisp_Object keys;
1777 {
1778   int len;
1779   int i, i_byte;
1780   Lisp_Object sep;
1781   Lisp_Object *args;
1782
1783   if (STRINGP (keys))
1784     {
1785       Lisp_Object vector;
1786       vector = Fmake_vector (Flength (keys), Qnil);
1787       for (i = 0, i_byte = 0; i < XSTRING (keys)->size; )
1788         {
1789           int c;
1790           int i_before = i;
1791
1792           FETCH_STRING_CHAR_ADVANCE (c, keys, i, i_byte);
1793           if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
1794             c ^= 0200 | meta_modifier;
1795           XSETFASTINT (XVECTOR (vector)->contents[i_before], c);
1796         }
1797       keys = vector;
1798     }
1799
1800   if (VECTORP (keys))
1801     {
1802       /* In effect, this computes
1803          (mapconcat 'single-key-description keys " ")
1804          but we shouldn't use mapconcat because it can do GC.  */
1805
1806       len = XVECTOR (keys)->size;
1807       sep = build_string (" ");
1808       /* This has one extra element at the end that we don't pass to Fconcat.  */
1809       args = (Lisp_Object *) alloca (len * 2 * sizeof (Lisp_Object));
1810
1811       for (i = 0; i < len; i++)
1812         {
1813           args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i],
1814                                                  Qnil);
1815           args[i * 2 + 1] = sep;
1816         }
1817     }
1818   else if (CONSP (keys))
1819     {
1820       /* In effect, this computes
1821          (mapconcat 'single-key-description keys " ")
1822          but we shouldn't use mapconcat because it can do GC.  */
1823
1824       len = XFASTINT (Flength (keys));
1825       sep = build_string (" ");
1826       /* This has one extra element at the end that we don't pass to Fconcat.  */
1827       args = (Lisp_Object *) alloca (len * 2 * sizeof (Lisp_Object));
1828
1829       for (i = 0; i < len; i++)
1830         {
1831           args[i * 2] = Fsingle_key_description (XCAR (keys), Qnil);
1832           args[i * 2 + 1] = sep;
1833           keys = XCDR (keys);
1834         }
1835     }
1836   else
1837     keys = wrong_type_argument (Qarrayp, keys);
1838
1839   return Fconcat (len * 2 - 1, args);
1840 }
1841
1842 char *
1843 push_key_description (c, p)
1844      register unsigned int c;
1845      register char *p;
1846 {
1847   unsigned c2;
1848
1849   /* Clear all the meaningless bits above the meta bit.  */
1850   c &= meta_modifier | ~ - meta_modifier;
1851   c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
1852              | meta_modifier | shift_modifier | super_modifier);
1853
1854   if (c & alt_modifier)
1855     {
1856       *p++ = 'A';
1857       *p++ = '-';
1858       c -= alt_modifier;
1859     }
1860   if ((c & ctrl_modifier) != 0
1861       || (c2 < ' ' && c2 != 27 && c2 != '\t' && c2 != Ctl ('M')))
1862     {
1863       *p++ = 'C';
1864       *p++ = '-';
1865       c &= ~ctrl_modifier;
1866     }
1867   if (c & hyper_modifier)
1868     {
1869       *p++ = 'H';
1870       *p++ = '-';
1871       c -= hyper_modifier;
1872     }
1873   if (c & meta_modifier)
1874     {
1875       *p++ = 'M';
1876       *p++ = '-';
1877       c -= meta_modifier;
1878     }
1879   if (c & shift_modifier)
1880     {
1881       *p++ = 'S';
1882       *p++ = '-';
1883       c -= shift_modifier;
1884     }
1885   if (c & super_modifier)
1886     {
1887       *p++ = 's';
1888       *p++ = '-';
1889       c -= super_modifier;
1890     }
1891   if (c < 040)
1892     {
1893       if (c == 033)
1894         {
1895           *p++ = 'E';
1896           *p++ = 'S';
1897           *p++ = 'C';
1898         }
1899       else if (c == '\t')
1900         {
1901           *p++ = 'T';
1902           *p++ = 'A';
1903           *p++ = 'B';
1904         }
1905       else if (c == Ctl ('M'))
1906         {
1907           *p++ = 'R';
1908           *p++ = 'E';
1909           *p++ = 'T';
1910         }
1911       else
1912         {
1913           /* `C-' already added above.  */
1914           if (c > 0 && c <= Ctl ('Z'))
1915             *p++ = c + 0140;
1916           else
1917             *p++ = c + 0100;
1918         }
1919     }
1920   else if (c == 0177)
1921     {
1922       *p++ = 'D';
1923       *p++ = 'E';
1924       *p++ = 'L';
1925     }
1926   else if (c == ' ')
1927    {
1928       *p++ = 'S';
1929       *p++ = 'P';
1930       *p++ = 'C';
1931     }
1932   else if (c < 128
1933            || (NILP (current_buffer->enable_multibyte_characters)
1934                && SINGLE_BYTE_CHAR_P (c)))
1935     *p++ = c;
1936   else
1937     {
1938       if (! NILP (current_buffer->enable_multibyte_characters))
1939         c = unibyte_char_to_multibyte (c);
1940
1941       if (NILP (current_buffer->enable_multibyte_characters)
1942           || SINGLE_BYTE_CHAR_P (c)
1943           || ! char_valid_p (c, 0))
1944         {
1945           int bit_offset;
1946           *p++ = '\\';
1947           /* The biggest character code uses 19 bits.  */
1948           for (bit_offset = 18; bit_offset >= 0; bit_offset -= 3)
1949             {
1950               if (c >= (1 << bit_offset))
1951                 *p++ = ((c & (7 << bit_offset)) >> bit_offset) + '0';
1952             }
1953         }
1954       else
1955         {
1956           p += CHAR_STRING (c, p);
1957         }
1958     }
1959
1960   return p;
1961 }
1962
1963 /* This function cannot GC.  */
1964
1965 DEFUN ("single-key-description", Fsingle_key_description,
1966        Ssingle_key_description, 1, 2, 0,
1967   "Return a pretty description of command character KEY.\n\
1968 Control characters turn into C-whatever, etc.\n\
1969 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1970 around function keys and event symbols.")
1971   (key, no_angles)
1972      Lisp_Object key, no_angles;
1973 {
1974   if (CONSP (key) && lucid_event_type_list_p (key))
1975     key = Fevent_convert_list (key);
1976
1977   key = EVENT_HEAD (key);
1978
1979   if (INTEGERP (key))           /* Normal character */
1980     {
1981       unsigned int charset, c1, c2;
1982       int without_bits = XINT (key) & ~((-1) << CHARACTERBITS);
1983
1984       if (SINGLE_BYTE_CHAR_P (without_bits))
1985         charset = 0;
1986       else
1987         SPLIT_CHAR (without_bits, charset, c1, c2);
1988
1989       if (charset
1990           && CHARSET_DEFINED_P (charset)
1991           && ((c1 >= 0 && c1 < 32)
1992               || (c2 >= 0 && c2 < 32)))
1993         {
1994           /* Handle a generic character.  */
1995           Lisp_Object name;
1996           name = CHARSET_TABLE_INFO (charset, CHARSET_LONG_NAME_IDX);
1997           CHECK_STRING (name, 0);
1998           return concat2 (build_string ("Character set "), name);
1999         }
2000       else
2001         {
2002           char tem[KEY_DESCRIPTION_SIZE];
2003
2004           *push_key_description (XUINT (key), tem) = 0;
2005           return build_string (tem);
2006         }
2007     }
2008   else if (SYMBOLP (key))       /* Function key or event-symbol */
2009     {
2010       if (NILP (no_angles))
2011         {
2012           char *buffer
2013             = (char *) alloca (STRING_BYTES (XSYMBOL (key)->name) + 5);
2014           sprintf (buffer, "<%s>", XSYMBOL (key)->name->data);
2015           return build_string (buffer);
2016         }
2017       else
2018         return Fsymbol_name (key);
2019     }
2020   else if (STRINGP (key))       /* Buffer names in the menubar.  */
2021     return Fcopy_sequence (key);
2022   else
2023     error ("KEY must be an integer, cons, symbol, or string");
2024 }
2025
2026 char *
2027 push_text_char_description (c, p)
2028      register unsigned int c;
2029      register char *p;
2030 {
2031   if (c >= 0200)
2032     {
2033       *p++ = 'M';
2034       *p++ = '-';
2035       c -= 0200;
2036     }
2037   if (c < 040)
2038     {
2039       *p++ = '^';
2040       *p++ = c + 64;            /* 'A' - 1 */
2041     }
2042   else if (c == 0177)
2043     {
2044       *p++ = '^';
2045       *p++ = '?';
2046     }
2047   else
2048     *p++ = c;
2049   return p;
2050 }
2051
2052 /* This function cannot GC.  */
2053
2054 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0,
2055   "Return a pretty description of file-character CHARACTER.\n\
2056 Control characters turn into \"^char\", etc.")
2057   (character)
2058      Lisp_Object character;
2059 {
2060   /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6).  */
2061   unsigned char str[6];
2062   int c;
2063
2064   CHECK_NUMBER (character, 0);
2065
2066   c = XINT (character);
2067   if (!SINGLE_BYTE_CHAR_P (c))
2068     {
2069       int len = CHAR_STRING (c, str);
2070
2071       return make_multibyte_string (str, 1, len);
2072     }
2073
2074   *push_text_char_description (c & 0377, str) = 0;
2075
2076   return build_string (str);
2077 }
2078
2079 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2080    a meta bit.  */
2081 static int
2082 ascii_sequence_p (seq)
2083      Lisp_Object seq;
2084 {
2085   int i;
2086   int len = XINT (Flength (seq));
2087
2088   for (i = 0; i < len; i++)
2089     {
2090       Lisp_Object ii, elt;
2091
2092       XSETFASTINT (ii, i);
2093       elt = Faref (seq, ii);
2094
2095       if (!INTEGERP (elt)
2096           || (XUINT (elt) & ~CHAR_META) >= 0x80)
2097         return 0;
2098     }
2099
2100   return 1;
2101 }
2102
2103 \f
2104 /* where-is - finding a command in a set of keymaps.                    */
2105
2106 static Lisp_Object where_is_internal_1 ();
2107 static void where_is_internal_2 ();
2108
2109 /* This function can GC if Flookup_key autoloads any keymaps.  */
2110
2111 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,
2112   "Return list of keys that invoke DEFINITION.\n\
2113 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2114 If KEYMAP is nil, search all the currently active keymaps.\n\
2115 \n\
2116 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2117 rather than a list of all possible key sequences.\n\
2118 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2119 no matter what it is.\n\
2120 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2121 and entirely reject menu bindings.\n\
2122 \n\
2123 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2124 to other keymaps or slots.  This makes it possible to search for an\n\
2125 indirect definition itself.")
2126   (definition, xkeymap, firstonly, noindirect)
2127      Lisp_Object definition, xkeymap;
2128      Lisp_Object firstonly, noindirect;
2129 {
2130   Lisp_Object maps;
2131   Lisp_Object found, sequences;
2132   Lisp_Object keymap1;
2133   int keymap_specified = !NILP (xkeymap);
2134   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
2135   /* 1 means ignore all menu bindings entirely.  */
2136   int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
2137
2138   /* Find keymaps accessible from `keymap' or the current
2139      context.  But don't muck with the value of `keymap',
2140      because `where_is_internal_1' uses it to check for
2141      shadowed bindings. */
2142   keymap1 = xkeymap;
2143   if (! keymap_specified)
2144     keymap1 = get_local_map (PT, current_buffer, keymap);
2145
2146   if (!NILP (keymap1))
2147     maps = nconc2 (Faccessible_keymaps (get_keymap (keymap1), Qnil),
2148                    Faccessible_keymaps (get_keymap (current_global_map),
2149                                         Qnil));
2150   else
2151     {
2152       keymap1 = xkeymap;
2153       if (! keymap_specified)
2154         keymap1 = get_local_map (PT, current_buffer, local_map);
2155
2156       if (!NILP (keymap1))
2157         maps = nconc2 (Faccessible_keymaps (get_keymap (keymap1), Qnil),
2158                        Faccessible_keymaps (get_keymap (current_global_map),
2159                                             Qnil));
2160       else
2161         maps = Faccessible_keymaps (get_keymap (current_global_map), Qnil);
2162     }
2163
2164   /* Put the minor mode keymaps on the front.  */
2165   if (! keymap_specified)
2166     {
2167       Lisp_Object minors;
2168       minors = Fnreverse (Fcurrent_minor_mode_maps ());
2169       while (!NILP (minors))
2170         {
2171           maps = nconc2 (Faccessible_keymaps (get_keymap (XCAR (minors)),
2172                                               Qnil),
2173                          maps);
2174           minors = XCDR (minors);
2175         }
2176     }
2177
2178   GCPRO5 (definition, xkeymap, maps, found, sequences);
2179   found = Qnil;
2180   sequences = Qnil;
2181
2182   for (; !NILP (maps); maps = Fcdr (maps))
2183     {
2184       /* Key sequence to reach map, and the map that it reaches */
2185       register Lisp_Object this, map;
2186
2187       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2188          [M-CHAR] sequences, check if last character of the sequence
2189          is the meta-prefix char.  */
2190       Lisp_Object last;
2191       int last_is_meta;
2192
2193       this = Fcar (Fcar (maps));
2194       map  = Fcdr (Fcar (maps));
2195       last = make_number (XINT (Flength (this)) - 1);
2196       last_is_meta = (XINT (last) >= 0
2197                       && EQ (Faref (this, last), meta_prefix_char));
2198
2199       QUIT;
2200
2201       while (CONSP (map))
2202         {
2203           /* Because the code we want to run on each binding is rather
2204              large, we don't want to have two separate loop bodies for
2205              sparse keymap bindings and tables; we want to iterate one
2206              loop body over both keymap and vector bindings.
2207
2208              For this reason, if Fcar (map) is a vector, we don't
2209              advance map to the next element until i indicates that we
2210              have finished off the vector.  */
2211           Lisp_Object elt, key, binding;
2212           elt = XCAR (map);
2213           map = XCDR (map);
2214
2215           sequences = Qnil;
2216
2217           QUIT;
2218
2219           /* Set key and binding to the current key and binding, and
2220              advance map and i to the next binding.  */
2221           if (VECTORP (elt))
2222             {
2223               Lisp_Object sequence;
2224               int i;
2225               /* In a vector, look at each element.  */
2226               for (i = 0; i < XVECTOR (elt)->size; i++)
2227                 {
2228                   binding = XVECTOR (elt)->contents[i];
2229                   XSETFASTINT (key, i);
2230                   sequence = where_is_internal_1 (binding, key, definition,
2231                                                   noindirect, xkeymap, this,
2232                                                   last, nomenus, last_is_meta);
2233                   if (!NILP (sequence))
2234                     sequences = Fcons (sequence, sequences);
2235                 }
2236             }
2237           else if (CHAR_TABLE_P (elt))
2238             {
2239               Lisp_Object indices[3];
2240               Lisp_Object args;
2241
2242               args = Fcons (Fcons (Fcons (definition, noindirect),
2243                                    Fcons (xkeymap, Qnil)),
2244                             Fcons (Fcons (this, last),
2245                                    Fcons (make_number (nomenus),
2246                                           make_number (last_is_meta))));
2247               map_char_table (where_is_internal_2, Qnil, elt, args,
2248                               0, indices);
2249               sequences = XCDR (XCDR (XCAR (args)));
2250             }
2251           else if (CONSP (elt))
2252             {
2253               Lisp_Object sequence;
2254
2255               key = XCAR (elt);
2256               binding = XCDR (elt);
2257
2258               sequence = where_is_internal_1 (binding, key, definition,
2259                                               noindirect, xkeymap, this,
2260                                               last, nomenus, last_is_meta);
2261               if (!NILP (sequence))
2262                 sequences = Fcons (sequence, sequences);
2263             }
2264
2265
2266           for (; ! NILP (sequences); sequences = XCDR (sequences))
2267             {
2268               Lisp_Object sequence;
2269
2270               sequence = XCAR (sequences);
2271
2272               /* It is a true unshadowed match.  Record it, unless it's already
2273                  been seen (as could happen when inheriting keymaps).  */
2274               if (NILP (Fmember (sequence, found)))
2275                 found = Fcons (sequence, found);
2276
2277               /* If firstonly is Qnon_ascii, then we can return the first
2278                  binding we find.  If firstonly is not Qnon_ascii but not
2279                  nil, then we should return the first ascii-only binding
2280                  we find.  */
2281               if (EQ (firstonly, Qnon_ascii))
2282                 RETURN_UNGCPRO (sequence);
2283               else if (! NILP (firstonly) && ascii_sequence_p (sequence))
2284                 RETURN_UNGCPRO (sequence);
2285             }
2286         }
2287     }
2288
2289   UNGCPRO;
2290
2291   found = Fnreverse (found);
2292
2293   /* firstonly may have been t, but we may have gone all the way through
2294      the keymaps without finding an all-ASCII key sequence.  So just
2295      return the best we could find.  */
2296   if (! NILP (firstonly))
2297     return Fcar (found);
2298
2299   return found;
2300 }
2301
2302 /* This is the function that Fwhere_is_internal calls using map_char_table.
2303    ARGS has the form
2304    (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2305     .
2306     ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2307    Since map_char_table doesn't really use the return value from this function,
2308    we the result append to RESULT, the slot in ARGS.
2309
2310    This function can GC because it calls where_is_internal_1 which can
2311    GC.  */
2312
2313 static void
2314 where_is_internal_2 (args, key, binding)
2315      Lisp_Object args, key, binding;
2316 {
2317   Lisp_Object definition, noindirect, keymap, this, last;
2318   Lisp_Object result, sequence;
2319   int nomenus, last_is_meta;
2320   struct gcpro gcpro1, gcpro2, gcpro3;
2321
2322   GCPRO3 (args, key, binding);
2323   result = XCDR (XCDR (XCAR (args)));
2324   definition = XCAR (XCAR (XCAR (args)));
2325   noindirect = XCDR (XCAR (XCAR (args)));
2326   keymap = XCAR (XCDR (XCAR (args)));
2327   this = XCAR (XCAR (XCDR (args)));
2328   last = XCDR (XCAR (XCDR (args)));
2329   nomenus = XFASTINT (XCAR (XCDR (XCDR (args))));
2330   last_is_meta = XFASTINT (XCDR (XCDR (XCDR (args))));
2331
2332   sequence = where_is_internal_1 (binding, key, definition, noindirect, keymap,
2333                                   this, last, nomenus, last_is_meta);
2334
2335   if (!NILP (sequence))
2336     XCDR (XCDR (XCAR (args))) = Fcons (sequence, result);
2337
2338   UNGCPRO;
2339 }
2340
2341
2342 /* This function can GC.because Flookup_key calls get_keymap_1 with
2343    non-zero argument AUTOLOAD.  */
2344
2345 static Lisp_Object
2346 where_is_internal_1 (binding, key, definition, noindirect, keymap, this, last,
2347                      nomenus, last_is_meta)
2348      Lisp_Object binding, key, definition, noindirect, keymap, this, last;
2349      int nomenus, last_is_meta;
2350 {
2351   Lisp_Object sequence;
2352   int keymap_specified = !NILP (keymap);
2353   struct gcpro gcpro1, gcpro2;
2354
2355   /* Search through indirections unless that's not wanted.  */
2356   if (NILP (noindirect))
2357     {
2358       if (nomenus)
2359         {
2360           while (1)
2361             {
2362               Lisp_Object map, tem;
2363               /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
2364               map = get_keymap_1 (Fcar_safe (definition), 0, 0);
2365               tem = Fkeymapp (map);
2366               if (!NILP (tem))
2367                 definition = access_keymap (map, Fcdr (definition), 0, 0);
2368               else
2369                 break;
2370             }
2371           /* If the contents are (menu-item ...) or (STRING ...), reject.  */
2372           if (CONSP (definition)
2373               && (EQ (XCAR (definition),Qmenu_item)
2374                   || STRINGP (XCAR (definition))))
2375             return Qnil;
2376         }
2377       else
2378         binding = get_keyelt (binding, 0);
2379     }
2380
2381   /* End this iteration if this element does not match
2382      the target.  */
2383
2384   if (CONSP (definition))
2385     {
2386       Lisp_Object tem;
2387       tem = Fequal (binding, definition);
2388       if (NILP (tem))
2389         return Qnil;
2390     }
2391   else
2392     if (!EQ (binding, definition))
2393       return Qnil;
2394
2395   /* We have found a match.
2396      Construct the key sequence where we found it.  */
2397   if (INTEGERP (key) && last_is_meta)
2398     {
2399       sequence = Fcopy_sequence (this);
2400       Faset (sequence, last, make_number (XINT (key) | meta_modifier));
2401     }
2402   else
2403     sequence = append_key (this, key);
2404
2405   /* Verify that this key binding is not shadowed by another
2406      binding for the same key, before we say it exists.
2407
2408      Mechanism: look for local definition of this key and if
2409      it is defined and does not match what we found then
2410      ignore this key.
2411
2412      Either nil or number as value from Flookup_key
2413      means undefined.  */
2414   GCPRO2 (sequence, binding);
2415   if (keymap_specified)
2416     {
2417       binding = Flookup_key (keymap, sequence, Qnil);
2418       if (!NILP (binding) && !INTEGERP (binding))
2419         {
2420           if (CONSP (definition))
2421             {
2422               Lisp_Object tem;
2423               tem = Fequal (binding, definition);
2424               if (NILP (tem))
2425                 RETURN_UNGCPRO (Qnil);
2426             }
2427           else
2428             if (!EQ (binding, definition))
2429               RETURN_UNGCPRO (Qnil);
2430         }
2431     }
2432   else
2433     {
2434       binding = Fkey_binding (sequence, Qnil);
2435       if (!EQ (binding, definition))
2436         RETURN_UNGCPRO (Qnil);
2437     }
2438
2439   RETURN_UNGCPRO (sequence);
2440 }
2441 \f
2442 /* describe-bindings - summarizing all the bindings in a set of keymaps.  */
2443
2444 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal, Sdescribe_bindings_internal, 0, 2, "",
2445   "Show a list of all defined keys, and their definitions.\n\
2446 We put that list in a buffer, and display the buffer.\n\
2447 \n\
2448 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2449 \(Ordinarily these are omitted from the output.)\n\
2450 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2451 then we display only bindings that start with that prefix.")
2452   (menus, prefix)
2453      Lisp_Object menus, prefix;
2454 {
2455   register Lisp_Object thisbuf;
2456   XSETBUFFER (thisbuf, current_buffer);
2457   internal_with_output_to_temp_buffer ("*Help*",
2458                                        describe_buffer_bindings,
2459                                        list3 (thisbuf, prefix, menus));
2460   return Qnil;
2461 }
2462
2463 /* ARG is (BUFFER PREFIX MENU-FLAG).  */
2464
2465 static Lisp_Object
2466 describe_buffer_bindings (arg)
2467      Lisp_Object arg;
2468 {
2469   Lisp_Object descbuf, prefix, shadow;
2470   int nomenu;
2471   register Lisp_Object start1;
2472   struct gcpro gcpro1;
2473
2474   char *alternate_heading
2475     = "\
2476 Keyboard translations:\n\n\
2477 You type        Translation\n\
2478 --------        -----------\n";
2479
2480   descbuf = XCAR (arg);
2481   arg = XCDR (arg);
2482   prefix = XCAR (arg);
2483   arg = XCDR (arg);
2484   nomenu = NILP (XCAR (arg));
2485
2486   shadow = Qnil;
2487   GCPRO1 (shadow);
2488
2489   Fset_buffer (Vstandard_output);
2490
2491   /* Report on alternates for keys.  */
2492   if (STRINGP (Vkeyboard_translate_table) && !NILP (prefix))
2493     {
2494       int c;
2495       unsigned char *translate = XSTRING (Vkeyboard_translate_table)->data;
2496       int translate_len = XSTRING (Vkeyboard_translate_table)->size;
2497
2498       for (c = 0; c < translate_len; c++)
2499         if (translate[c] != c)
2500           {
2501             char buf[KEY_DESCRIPTION_SIZE];
2502             char *bufend;
2503
2504             if (alternate_heading)
2505               {
2506                 insert_string (alternate_heading);
2507                 alternate_heading = 0;
2508               }
2509
2510             bufend = push_key_description (translate[c], buf);
2511             insert (buf, bufend - buf);
2512             Findent_to (make_number (16), make_number (1));
2513             bufend = push_key_description (c, buf);
2514             insert (buf, bufend - buf);
2515
2516             insert ("\n", 1);
2517           }
2518
2519       insert ("\n", 1);
2520     }
2521
2522   if (!NILP (Vkey_translation_map))
2523     describe_map_tree (Vkey_translation_map, 0, Qnil, prefix,
2524                        "Key translations", nomenu, 1, 0);
2525
2526   {
2527     int i, nmaps;
2528     Lisp_Object *modes, *maps;
2529
2530     /* Temporarily switch to descbuf, so that we can get that buffer's
2531        minor modes correctly.  */
2532     Fset_buffer (descbuf);
2533
2534     if (!NILP (current_kboard->Voverriding_terminal_local_map)
2535         || !NILP (Voverriding_local_map))
2536       nmaps = 0;
2537     else
2538       nmaps = current_minor_maps (&modes, &maps);
2539     Fset_buffer (Vstandard_output);
2540
2541     /* Print the minor mode maps.  */
2542     for (i = 0; i < nmaps; i++)
2543       {
2544         /* The title for a minor mode keymap
2545            is constructed at run time.
2546            We let describe_map_tree do the actual insertion
2547            because it takes care of other features when doing so.  */
2548         char *title, *p;
2549
2550         if (!SYMBOLP (modes[i]))
2551           abort();
2552
2553         p = title = (char *) alloca (42 + XSYMBOL (modes[i])->name->size);
2554         *p++ = '\f';
2555         *p++ = '\n';
2556         *p++ = '`';
2557         bcopy (XSYMBOL (modes[i])->name->data, p,
2558                XSYMBOL (modes[i])->name->size);
2559         p += XSYMBOL (modes[i])->name->size;
2560         *p++ = '\'';
2561         bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings") - 1);
2562         p += sizeof (" Minor Mode Bindings") - 1;
2563         *p = 0;
2564
2565         describe_map_tree (maps[i], 1, shadow, prefix, title, nomenu, 0, 0);
2566         shadow = Fcons (maps[i], shadow);
2567       }
2568   }
2569
2570   /* Print the (major mode) local map.  */
2571   if (!NILP (current_kboard->Voverriding_terminal_local_map))
2572     start1 = current_kboard->Voverriding_terminal_local_map;
2573   else if (!NILP (Voverriding_local_map))
2574     start1 = Voverriding_local_map;
2575   else
2576     start1 = XBUFFER (descbuf)->keymap;
2577
2578   if (!NILP (start1))
2579     {
2580       describe_map_tree (start1, 1, shadow, prefix,
2581                          "\f\nMajor Mode Bindings", nomenu, 0, 0);
2582       shadow = Fcons (start1, shadow);
2583     }
2584
2585   describe_map_tree (current_global_map, 1, shadow, prefix,
2586                      "\f\nGlobal Bindings", nomenu, 0, 1);
2587
2588   /* Print the function-key-map translations under this prefix.  */
2589   if (!NILP (Vfunction_key_map))
2590     describe_map_tree (Vfunction_key_map, 0, Qnil, prefix,
2591                        "\f\nFunction key map translations", nomenu, 1, 0);
2592
2593   call0 (intern ("help-mode"));
2594   Fset_buffer (descbuf);
2595   UNGCPRO;
2596   return Qnil;
2597 }
2598
2599 /* Insert a description of the key bindings in STARTMAP,
2600     followed by those of all maps reachable through STARTMAP.
2601    If PARTIAL is nonzero, omit certain "uninteresting" commands
2602     (such as `undefined').
2603    If SHADOW is non-nil, it is a list of maps;
2604     don't mention keys which would be shadowed by any of them.
2605    PREFIX, if non-nil, says mention only keys that start with PREFIX.
2606    TITLE, if not 0, is a string to insert at the beginning.
2607    TITLE should not end with a colon or a newline; we supply that.
2608    If NOMENU is not 0, then omit menu-bar commands.
2609
2610    If TRANSL is nonzero, the definitions are actually key translations
2611    so print strings and vectors differently.
2612
2613    If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2614    to look through.  */
2615
2616 void
2617 describe_map_tree (startmap, partial, shadow, prefix, title, nomenu, transl,
2618                    always_title)
2619      Lisp_Object startmap, shadow, prefix;
2620      int partial;
2621      char *title;
2622      int nomenu;
2623      int transl;
2624      int always_title;
2625 {
2626   Lisp_Object maps, orig_maps, seen, sub_shadows;
2627   struct gcpro gcpro1, gcpro2, gcpro3;
2628   int something = 0;
2629   char *key_heading
2630     = "\
2631 key             binding\n\
2632 ---             -------\n";
2633
2634   orig_maps = maps = Faccessible_keymaps (startmap, prefix);
2635   seen = Qnil;
2636   sub_shadows = Qnil;
2637   GCPRO3 (maps, seen, sub_shadows);
2638
2639   if (nomenu)
2640     {
2641       Lisp_Object list;
2642
2643       /* Delete from MAPS each element that is for the menu bar.  */
2644       for (list = maps; !NILP (list); list = XCDR (list))
2645         {
2646           Lisp_Object elt, prefix, tem;
2647
2648           elt = Fcar (list);
2649           prefix = Fcar (elt);
2650           if (XVECTOR (prefix)->size >= 1)
2651             {
2652               tem = Faref (prefix, make_number (0));
2653               if (EQ (tem, Qmenu_bar))
2654                 maps = Fdelq (elt, maps);
2655             }
2656         }
2657     }
2658
2659   if (!NILP (maps) || always_title)
2660     {
2661       if (title)
2662         {
2663           insert_string (title);
2664           if (!NILP (prefix))
2665             {
2666               insert_string (" Starting With ");
2667               insert1 (Fkey_description (prefix));
2668             }
2669           insert_string (":\n");
2670         }
2671       insert_string (key_heading);
2672       something = 1;
2673     }
2674
2675   for (; !NILP (maps); maps = Fcdr (maps))
2676     {
2677       register Lisp_Object elt, prefix, tail;
2678
2679       elt = Fcar (maps);
2680       prefix = Fcar (elt);
2681
2682       sub_shadows = Qnil;
2683
2684       for (tail = shadow; CONSP (tail); tail = XCDR (tail))
2685         {
2686           Lisp_Object shmap;
2687
2688           shmap = XCAR (tail);
2689
2690           /* If the sequence by which we reach this keymap is zero-length,
2691              then the shadow map for this keymap is just SHADOW.  */
2692           if ((STRINGP (prefix) && XSTRING (prefix)->size == 0)
2693               || (VECTORP (prefix) && XVECTOR (prefix)->size == 0))
2694             ;
2695           /* If the sequence by which we reach this keymap actually has
2696              some elements, then the sequence's definition in SHADOW is
2697              what we should use.  */
2698           else
2699             {
2700               shmap = Flookup_key (shmap, Fcar (elt), Qt);
2701               if (INTEGERP (shmap))
2702                 shmap = Qnil;
2703             }
2704
2705           /* If shmap is not nil and not a keymap,
2706              it completely shadows this map, so don't
2707              describe this map at all.  */
2708           if (!NILP (shmap) && NILP (Fkeymapp (shmap)))
2709             goto skip;
2710
2711           if (!NILP (shmap))
2712             sub_shadows = Fcons (shmap, sub_shadows);
2713         }
2714
2715       /* Maps we have already listed in this loop shadow this map.  */
2716       for (tail = orig_maps; ! EQ (tail, maps); tail = XCDR (tail))
2717         {
2718           Lisp_Object tem;
2719           tem = Fequal (Fcar (XCAR (tail)), prefix);
2720           if (! NILP (tem))
2721             sub_shadows = Fcons (XCDR (XCAR (tail)), sub_shadows);
2722         }
2723
2724       describe_map (Fcdr (elt), prefix,
2725                     transl ? describe_translation : describe_command,
2726                     partial, sub_shadows, &seen, nomenu);
2727
2728     skip: ;
2729     }
2730
2731   if (something)
2732     insert_string ("\n");
2733
2734   UNGCPRO;
2735 }
2736
2737 static int previous_description_column;
2738
2739 static void
2740 describe_command (definition)
2741      Lisp_Object definition;
2742 {
2743   register Lisp_Object tem1;
2744   int column = current_column ();
2745   int description_column;
2746
2747   /* If column 16 is no good, go to col 32;
2748      but don't push beyond that--go to next line instead.  */
2749   if (column > 30)
2750     {
2751       insert_char ('\n');
2752       description_column = 32;
2753     }
2754   else if (column > 14 || (column > 10 && previous_description_column == 32))
2755     description_column = 32;
2756   else
2757     description_column = 16;
2758
2759   Findent_to (make_number (description_column), make_number (1));
2760   previous_description_column = description_column;
2761
2762   if (SYMBOLP (definition))
2763     {
2764       XSETSTRING (tem1, XSYMBOL (definition)->name);
2765       insert1 (tem1);
2766       insert_string ("\n");
2767     }
2768   else if (STRINGP (definition) || VECTORP (definition))
2769     insert_string ("Keyboard Macro\n");
2770   else
2771     {
2772       tem1 = Fkeymapp (definition);
2773       if (!NILP (tem1))
2774         insert_string ("Prefix Command\n");
2775       else
2776         insert_string ("??\n");
2777     }
2778 }
2779
2780 static void
2781 describe_translation (definition)
2782      Lisp_Object definition;
2783 {
2784   register Lisp_Object tem1;
2785
2786   Findent_to (make_number (16), make_number (1));
2787
2788   if (SYMBOLP (definition))
2789     {
2790       XSETSTRING (tem1, XSYMBOL (definition)->name);
2791       insert1 (tem1);
2792       insert_string ("\n");
2793     }
2794   else if (STRINGP (definition) || VECTORP (definition))
2795     {
2796       insert1 (Fkey_description (definition));
2797       insert_string ("\n");
2798     }
2799   else
2800     {
2801       tem1 = Fkeymapp (definition);
2802       if (!NILP (tem1))
2803         insert_string ("Prefix Command\n");
2804       else
2805         insert_string ("??\n");
2806     }
2807 }
2808
2809 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2810    Returns the first non-nil binding found in any of those maps.  */
2811
2812 static Lisp_Object
2813 shadow_lookup (shadow, key, flag)
2814      Lisp_Object shadow, key, flag;
2815 {
2816   Lisp_Object tail, value;
2817
2818   for (tail = shadow; CONSP (tail); tail = XCDR (tail))
2819     {
2820       value = Flookup_key (XCAR (tail), key, flag);
2821       if (!NILP (value))
2822         return value;
2823     }
2824   return Qnil;
2825 }
2826
2827 /* Describe the contents of map MAP, assuming that this map itself is
2828    reached by the sequence of prefix keys KEYS (a string or vector).
2829    PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above.  */
2830
2831 static void
2832 describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
2833      register Lisp_Object map;
2834      Lisp_Object keys;
2835      void (*elt_describer) P_ ((Lisp_Object));
2836      int partial;
2837      Lisp_Object shadow;
2838      Lisp_Object *seen;
2839      int nomenu;
2840 {
2841   Lisp_Object elt_prefix;
2842   Lisp_Object tail, definition, event;
2843   Lisp_Object tem;
2844   Lisp_Object suppress;
2845   Lisp_Object kludge;
2846   int first = 1;
2847   struct gcpro gcpro1, gcpro2, gcpro3;
2848
2849   if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
2850     {
2851       /* Call Fkey_description first, to avoid GC bug for the other string.  */
2852       tem = Fkey_description (keys);
2853       elt_prefix = concat2 (tem, build_string (" "));
2854     }
2855   else
2856     elt_prefix = Qnil;
2857
2858   if (partial)
2859     suppress = intern ("suppress-keymap");
2860
2861   /* This vector gets used to present single keys to Flookup_key.  Since
2862      that is done once per keymap element, we don't want to cons up a
2863      fresh vector every time.  */
2864   kludge = Fmake_vector (make_number (1), Qnil);
2865   definition = Qnil;
2866
2867   GCPRO3 (elt_prefix, definition, kludge);
2868
2869   for (tail = map; CONSP (tail); tail = XCDR (tail))
2870     {
2871       QUIT;
2872
2873       if (VECTORP (XCAR (tail))
2874           || CHAR_TABLE_P (XCAR (tail)))
2875         describe_vector (XCAR (tail),
2876                          elt_prefix, elt_describer, partial, shadow, map,
2877                          (int *)0, 0);
2878       else if (CONSP (XCAR (tail)))
2879         {
2880           event = XCAR (XCAR (tail));
2881
2882           /* Ignore bindings whose "keys" are not really valid events.
2883              (We get these in the frames and buffers menu.)  */
2884           if (! (SYMBOLP (event) || INTEGERP (event)))
2885             continue;
2886
2887           if (nomenu && EQ (event, Qmenu_bar))
2888             continue;
2889
2890           definition = get_keyelt (XCDR (XCAR (tail)), 0);
2891
2892           /* Don't show undefined commands or suppressed commands.  */
2893           if (NILP (definition)) continue;
2894           if (SYMBOLP (definition) && partial)
2895             {
2896               tem = Fget (definition, suppress);
2897               if (!NILP (tem))
2898                 continue;
2899             }
2900
2901           /* Don't show a command that isn't really visible
2902              because a local definition of the same key shadows it.  */
2903
2904           XVECTOR (kludge)->contents[0] = event;
2905           if (!NILP (shadow))
2906             {
2907               tem = shadow_lookup (shadow, kludge, Qt);
2908               if (!NILP (tem)) continue;
2909             }
2910
2911           tem = Flookup_key (map, kludge, Qt);
2912           if (! EQ (tem, definition)) continue;
2913
2914           if (first)
2915             {
2916               previous_description_column = 0;
2917               insert ("\n", 1);
2918               first = 0;
2919             }
2920
2921           if (!NILP (elt_prefix))
2922             insert1 (elt_prefix);
2923
2924           /* THIS gets the string to describe the character EVENT.  */
2925           insert1 (Fsingle_key_description (event, Qnil));
2926
2927           /* Print a description of the definition of this character.
2928              elt_describer will take care of spacing out far enough
2929              for alignment purposes.  */
2930           (*elt_describer) (definition);
2931         }
2932       else if (EQ (XCAR (tail), Qkeymap))
2933         {
2934           /* The same keymap might be in the structure twice, if we're
2935              using an inherited keymap.  So skip anything we've already
2936              encountered.  */
2937           tem = Fassq (tail, *seen);
2938           if (CONSP (tem) && !NILP (Fequal (XCAR (tem), keys)))
2939             break;
2940           *seen = Fcons (Fcons (tail, keys), *seen);
2941         }
2942     }
2943
2944   UNGCPRO;
2945 }
2946
2947 static void
2948 describe_vector_princ (elt)
2949      Lisp_Object elt;
2950 {
2951   Findent_to (make_number (16), make_number (1));
2952   Fprinc (elt, Qnil);
2953   Fterpri (Qnil);
2954 }
2955
2956 DEFUN ("describe-vector", Fdescribe_vector, Sdescribe_vector, 1, 1, 0,
2957   "Insert a description of contents of VECTOR.\n\
2958 This is text showing the elements of vector matched against indices.")
2959   (vector)
2960      Lisp_Object vector;
2961 {
2962   int count = specpdl_ptr - specpdl;
2963
2964   specbind (Qstandard_output, Fcurrent_buffer ());
2965   CHECK_VECTOR_OR_CHAR_TABLE (vector, 0);
2966   describe_vector (vector, Qnil, describe_vector_princ, 0,
2967                    Qnil, Qnil, (int *)0, 0);
2968
2969   return unbind_to (count, Qnil);
2970 }
2971
2972 /* Insert in the current buffer a description of the contents of VECTOR.
2973    We call ELT_DESCRIBER to insert the description of one value found
2974    in VECTOR.
2975
2976    ELT_PREFIX describes what "comes before" the keys or indices defined
2977    by this vector.  This is a human-readable string whose size
2978    is not necessarily related to the situation.
2979
2980    If the vector is in a keymap, ELT_PREFIX is a prefix key which
2981    leads to this keymap.
2982
2983    If the vector is a chartable, ELT_PREFIX is the vector
2984    of bytes that lead to the character set or portion of a character
2985    set described by this chartable.
2986
2987    If PARTIAL is nonzero, it means do not mention suppressed commands
2988    (that assumes the vector is in a keymap).
2989
2990    SHADOW is a list of keymaps that shadow this map.
2991    If it is non-nil, then we look up the key in those maps
2992    and we don't mention it now if it is defined by any of them.
2993
2994    ENTIRE_MAP is the keymap in which this vector appears.
2995    If the definition in effect in the whole map does not match
2996    the one in this vector, we ignore this one.
2997
2998    When describing a sub-char-table, INDICES is a list of
2999    indices at higher levels in this char-table,
3000    and CHAR_TABLE_DEPTH says how many levels down we have gone.  */
3001
3002 void
3003 describe_vector (vector, elt_prefix, elt_describer,
3004                  partial, shadow, entire_map,
3005                  indices, char_table_depth)
3006      register Lisp_Object vector;
3007      Lisp_Object elt_prefix;
3008      void (*elt_describer) P_ ((Lisp_Object));
3009      int partial;
3010      Lisp_Object shadow;
3011      Lisp_Object entire_map;
3012      int *indices;
3013      int char_table_depth;
3014 {
3015   Lisp_Object definition;
3016   Lisp_Object tem2;
3017   register int i;
3018   Lisp_Object suppress;
3019   Lisp_Object kludge;
3020   int first = 1;
3021   struct gcpro gcpro1, gcpro2, gcpro3;
3022   /* Range of elements to be handled.  */
3023   int from, to;
3024   /* A flag to tell if a leaf in this level of char-table is not a
3025      generic character (i.e. a complete multibyte character).  */
3026   int complete_char;
3027   int character;
3028   int starting_i;
3029
3030   if (indices == 0)
3031     indices = (int *) alloca (3 * sizeof (int));
3032
3033   definition = Qnil;
3034
3035   /* This vector gets used to present single keys to Flookup_key.  Since
3036      that is done once per vector element, we don't want to cons up a
3037      fresh vector every time.  */
3038   kludge = Fmake_vector (make_number (1), Qnil);
3039   GCPRO3 (elt_prefix, definition, kludge);
3040
3041   if (partial)
3042     suppress = intern ("suppress-keymap");
3043
3044   if (CHAR_TABLE_P (vector))
3045     {
3046       if (char_table_depth == 0)
3047         {
3048           /* VECTOR is a top level char-table.  */
3049           complete_char = 1;
3050           from = 0;
3051           to = CHAR_TABLE_ORDINARY_SLOTS;
3052         }
3053       else
3054         {
3055           /* VECTOR is a sub char-table.  */
3056           if (char_table_depth >= 3)
3057             /* A char-table is never that deep.  */
3058             error ("Too deep char table");
3059
3060           complete_char
3061             = (CHARSET_VALID_P (indices[0])
3062                && ((CHARSET_DIMENSION (indices[0]) == 1
3063                     && char_table_depth == 1)
3064                    || char_table_depth == 2));
3065
3066           /* Meaningful elements are from 32th to 127th.  */
3067           from = 32;
3068           to = SUB_CHAR_TABLE_ORDINARY_SLOTS;
3069         }
3070     }
3071   else
3072     {
3073       /* This does the right thing for ordinary vectors.  */
3074
3075       complete_char = 1;
3076       from = 0;
3077       to = XVECTOR (vector)->size;
3078     }
3079
3080   for (i = from; i < to; i++)
3081     {
3082       QUIT;
3083
3084       if (CHAR_TABLE_P (vector))
3085         {
3086           if (char_table_depth == 0 && i >= CHAR_TABLE_SINGLE_BYTE_SLOTS)
3087             complete_char = 0;
3088
3089           if (i >= CHAR_TABLE_SINGLE_BYTE_SLOTS
3090               && !CHARSET_DEFINED_P (i - 128))
3091             continue;
3092
3093           definition
3094             = get_keyelt (XCHAR_TABLE (vector)->contents[i], 0);
3095         }
3096       else
3097         definition = get_keyelt (XVECTOR (vector)->contents[i], 0);
3098
3099       if (NILP (definition)) continue;
3100
3101       /* Don't mention suppressed commands.  */
3102       if (SYMBOLP (definition) && partial)
3103         {
3104           Lisp_Object tem;
3105
3106           tem = Fget (definition, suppress);
3107
3108           if (!NILP (tem)) continue;
3109         }
3110
3111       /* Set CHARACTER to the character this entry describes, if any.
3112          Also update *INDICES.  */
3113       if (CHAR_TABLE_P (vector))
3114         {
3115           indices[char_table_depth] = i;
3116
3117           if (char_table_depth == 0)
3118             {
3119               character = i;
3120               indices[0] = i - 128;
3121             }
3122           else if (complete_char)
3123             {
3124               character = MAKE_CHAR (indices[0], indices[1], indices[2]);
3125             }
3126           else
3127             character = 0;
3128         }
3129       else
3130         character = i;
3131
3132       /* If this binding is shadowed by some other map, ignore it.  */
3133       if (!NILP (shadow) && complete_char)
3134         {
3135           Lisp_Object tem;
3136
3137           XVECTOR (kludge)->contents[0] = make_number (character);
3138           tem = shadow_lookup (shadow, kludge, Qt);
3139
3140           if (!NILP (tem)) continue;
3141         }
3142
3143       /* Ignore this definition if it is shadowed by an earlier
3144          one in the same keymap.  */
3145       if (!NILP (entire_map) && complete_char)
3146         {
3147           Lisp_Object tem;
3148
3149           XVECTOR (kludge)->contents[0] = make_number (character);
3150           tem = Flookup_key (entire_map, kludge, Qt);
3151
3152           if (! EQ (tem, definition))
3153             continue;
3154         }
3155
3156       if (first)
3157         {
3158           if (char_table_depth == 0)
3159             insert ("\n", 1);
3160           first = 0;
3161         }
3162
3163       /* For a sub char-table, show the depth by indentation.
3164          CHAR_TABLE_DEPTH can be greater than 0 only for a char-table.  */
3165       if (char_table_depth > 0)
3166         insert ("    ", char_table_depth * 2); /* depth is 1 or 2.  */
3167
3168       /* Output the prefix that applies to every entry in this map.  */
3169       if (!NILP (elt_prefix))
3170         insert1 (elt_prefix);
3171
3172       /* Insert or describe the character this slot is for,
3173          or a description of what it is for.  */
3174       if (SUB_CHAR_TABLE_P (vector))
3175         {
3176           if (complete_char)
3177             insert_char (character);
3178           else
3179             {
3180               /* We need an octal representation for this block of
3181                  characters.  */
3182               char work[16];
3183               sprintf (work, "(row %d)", i);
3184               insert (work, strlen (work));
3185             }
3186         }
3187       else if (CHAR_TABLE_P (vector))
3188         {
3189           if (complete_char)
3190             insert1 (Fsingle_key_description (make_number (character), Qnil));
3191           else
3192             {
3193               /* Print the information for this character set.  */
3194               insert_string ("<");
3195               tem2 = CHARSET_TABLE_INFO (i - 128, CHARSET_SHORT_NAME_IDX);
3196               if (STRINGP (tem2))
3197                 insert_from_string (tem2, 0, 0, XSTRING (tem2)->size,
3198                                     STRING_BYTES (XSTRING (tem2)), 0);
3199               else
3200                 insert ("?", 1);
3201               insert (">", 1);
3202             }
3203         }
3204       else
3205         {
3206           insert1 (Fsingle_key_description (make_number (character), Qnil));
3207         }
3208
3209       /* If we find a sub char-table within a char-table,
3210          scan it recursively; it defines the details for
3211          a character set or a portion of a character set.  */
3212       if (CHAR_TABLE_P (vector) && SUB_CHAR_TABLE_P (definition))
3213         {
3214           insert ("\n", 1);
3215           describe_vector (definition, elt_prefix, elt_describer,
3216                            partial, shadow, entire_map,
3217                            indices, char_table_depth + 1);
3218           continue;
3219         }
3220
3221       starting_i = i;
3222
3223       /* Find all consecutive characters or rows that have the same
3224          definition.  But, for elements of a top level char table, if
3225          they are for charsets, we had better describe one by one even
3226          if they have the same definition.  */
3227       if (CHAR_TABLE_P (vector))
3228         {
3229           int limit = to;
3230
3231           if (char_table_depth == 0)
3232             limit = CHAR_TABLE_SINGLE_BYTE_SLOTS;
3233
3234           while (i + 1 < limit
3235                  && (tem2 = get_keyelt (XCHAR_TABLE (vector)->contents[i + 1], 0),
3236                      !NILP (tem2))
3237                  && !NILP (Fequal (tem2, definition)))
3238             i++;
3239         }
3240       else
3241         while (i + 1 < to
3242                && (tem2 = get_keyelt (XVECTOR (vector)->contents[i + 1], 0),
3243                    !NILP (tem2))
3244                && !NILP (Fequal (tem2, definition)))
3245           i++;
3246
3247
3248       /* If we have a range of more than one character,
3249          print where the range reaches to.  */
3250
3251       if (i != starting_i)
3252         {
3253           insert (" .. ", 4);
3254
3255           if (!NILP (elt_prefix))
3256             insert1 (elt_prefix);
3257
3258           if (CHAR_TABLE_P (vector))
3259             {
3260               if (char_table_depth == 0)
3261                 {
3262                   insert1 (Fsingle_key_description (make_number (i), Qnil));
3263                 }
3264               else if (complete_char)
3265                 {
3266                   indices[char_table_depth] = i;
3267                   character = MAKE_CHAR (indices[0], indices[1], indices[2]);
3268                   insert_char (character);
3269                 }
3270               else
3271                 {
3272                   /* We need an octal representation for this block of
3273                      characters.  */
3274                   char work[16];
3275                   sprintf (work, "(row %d)", i);
3276                   insert (work, strlen (work));
3277                 }
3278             }
3279           else
3280             {
3281               insert1 (Fsingle_key_description (make_number (i), Qnil));
3282             }
3283         }
3284
3285       /* Print a description of the definition of this character.
3286          elt_describer will take care of spacing out far enough
3287          for alignment purposes.  */
3288       (*elt_describer) (definition);
3289     }
3290
3291   /* For (sub) char-table, print `defalt' slot at last.  */
3292   if (CHAR_TABLE_P (vector) && !NILP (XCHAR_TABLE (vector)->defalt))
3293     {
3294       insert ("    ", char_table_depth * 2);
3295       insert_string ("<<default>>");
3296       (*elt_describer) (XCHAR_TABLE (vector)->defalt);
3297     }
3298
3299   UNGCPRO;
3300 }
3301 \f
3302 /* Apropos - finding all symbols whose names match a regexp.            */
3303 Lisp_Object apropos_predicate;
3304 Lisp_Object apropos_accumulate;
3305
3306 static void
3307 apropos_accum (symbol, string)
3308      Lisp_Object symbol, string;
3309 {
3310   register Lisp_Object tem;
3311
3312   tem = Fstring_match (string, Fsymbol_name (symbol), Qnil);
3313   if (!NILP (tem) && !NILP (apropos_predicate))
3314     tem = call1 (apropos_predicate, symbol);
3315   if (!NILP (tem))
3316     apropos_accumulate = Fcons (symbol, apropos_accumulate);
3317 }
3318
3319 DEFUN ("apropos-internal", Fapropos_internal, Sapropos_internal, 1, 2, 0,
3320   "Show all symbols whose names contain match for REGEXP.\n\
3321 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3322 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3323 Return list of symbols found.")
3324   (regexp, predicate)
3325      Lisp_Object regexp, predicate;
3326 {
3327   struct gcpro gcpro1, gcpro2;
3328   CHECK_STRING (regexp, 0);
3329   apropos_predicate = predicate;
3330   GCPRO2 (apropos_predicate, apropos_accumulate);
3331   apropos_accumulate = Qnil;
3332   map_obarray (Vobarray, apropos_accum, regexp);
3333   apropos_accumulate = Fsort (apropos_accumulate, Qstring_lessp);
3334   UNGCPRO;
3335   return apropos_accumulate;
3336 }
3337 \f
3338 void
3339 syms_of_keymap ()
3340 {
3341   Qkeymap = intern ("keymap");
3342   staticpro (&Qkeymap);
3343
3344   /* Now we are ready to set up this property, so we can
3345      create char tables.  */
3346   Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));
3347
3348   /* Initialize the keymaps standardly used.
3349      Each one is the value of a Lisp variable, and is also
3350      pointed to by a C variable */
3351
3352   global_map = Fmake_keymap (Qnil);
3353   Fset (intern ("global-map"), global_map);
3354
3355   current_global_map = global_map;
3356   staticpro (&global_map);
3357   staticpro (&current_global_map);
3358
3359   meta_map = Fmake_keymap (Qnil);
3360   Fset (intern ("esc-map"), meta_map);
3361   Ffset (intern ("ESC-prefix"), meta_map);
3362
3363   control_x_map = Fmake_keymap (Qnil);
3364   Fset (intern ("ctl-x-map"), control_x_map);
3365   Ffset (intern ("Control-X-prefix"), control_x_map);
3366
3367   DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands,
3368     "List of commands given new key bindings recently.\n\
3369 This is used for internal purposes during Emacs startup;\n\
3370 don't alter it yourself.");
3371   Vdefine_key_rebound_commands = Qt;
3372
3373   DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map,
3374     "Default keymap to use when reading from the minibuffer.");
3375   Vminibuffer_local_map = Fmake_sparse_keymap (Qnil);
3376
3377   DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map,
3378     "Local keymap for the minibuffer when spaces are not allowed.");
3379   Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil);
3380
3381   DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map,
3382     "Local keymap for minibuffer input with completion.");
3383   Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil);
3384
3385   DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map,
3386     "Local keymap for minibuffer input with completion, for exact match.");
3387   Vminibuffer_local_must_match_map = Fmake_sparse_keymap (Qnil);
3388
3389   DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist,
3390     "Alist of keymaps to use for minor modes.\n\
3391 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3392 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3393 If two active keymaps bind the same key, the keymap appearing earlier\n\
3394 in the list takes precedence.");
3395   Vminor_mode_map_alist = Qnil;
3396
3397   DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist,
3398     "Alist of keymaps to use for minor modes, in current major mode.\n\
3399 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3400 used the same way (and before `minor-mode-map-alist'); however,\n\
3401 it is provided for major modes to bind locally.");
3402   Vminor_mode_overriding_map_alist = Qnil;
3403
3404   DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
3405   "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3406 This allows Emacs to recognize function keys sent from ASCII\n\
3407 terminals at any point in a key sequence.\n\
3408 \n\
3409 The `read-key-sequence' function replaces any subsequence bound by\n\
3410 `function-key-map' with its binding.  More precisely, when the active\n\
3411 keymaps have no binding for the current key sequence but\n\
3412 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3413 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3414 continues with the new sequence.\n\
3415 \n\
3416 The events that come from bindings in `function-key-map' are not\n\
3417 themselves looked up in `function-key-map'.\n\
3418 \n\
3419 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3420 Typing `ESC O P' to `read-key-sequence' would return [f1].  Typing\n\
3421 `C-x ESC O P' would return [?\\C-x f1].  If [f1] were a prefix\n\
3422 key, typing `ESC O P x' would return [f1 x].");
3423   Vfunction_key_map = Fmake_sparse_keymap (Qnil);
3424
3425   DEFVAR_LISP ("key-translation-map", &Vkey_translation_map,
3426     "Keymap of key translations that can override keymaps.\n\
3427 This keymap works like `function-key-map', but comes after that,\n\
3428 and applies even for keys that have ordinary bindings.");
3429   Vkey_translation_map = Qnil;
3430
3431   Qsingle_key_description = intern ("single-key-description");
3432   staticpro (&Qsingle_key_description);
3433
3434   Qkey_description = intern ("key-description");
3435   staticpro (&Qkey_description);
3436
3437   Qkeymapp = intern ("keymapp");
3438   staticpro (&Qkeymapp);
3439
3440   Qnon_ascii = intern ("non-ascii");
3441   staticpro (&Qnon_ascii);
3442
3443   Qmenu_item = intern ("menu-item");
3444   staticpro (&Qmenu_item);
3445
3446   defsubr (&Skeymapp);
3447   defsubr (&Skeymap_parent);
3448   defsubr (&Sset_keymap_parent);
3449   defsubr (&Smake_keymap);
3450   defsubr (&Smake_sparse_keymap);
3451   defsubr (&Scopy_keymap);
3452   defsubr (&Skey_binding);
3453   defsubr (&Slocal_key_binding);
3454   defsubr (&Sglobal_key_binding);
3455   defsubr (&Sminor_mode_key_binding);
3456   defsubr (&Sdefine_key);
3457   defsubr (&Slookup_key);
3458   defsubr (&Sdefine_prefix_command);
3459   defsubr (&Suse_global_map);
3460   defsubr (&Suse_local_map);
3461   defsubr (&Scurrent_local_map);
3462   defsubr (&Scurrent_global_map);
3463   defsubr (&Scurrent_minor_mode_maps);
3464   defsubr (&Saccessible_keymaps);
3465   defsubr (&Skey_description);
3466   defsubr (&Sdescribe_vector);
3467   defsubr (&Ssingle_key_description);
3468   defsubr (&Stext_char_description);
3469   defsubr (&Swhere_is_internal);
3470   defsubr (&Sdescribe_bindings_internal);
3471   defsubr (&Sapropos_internal);
3472 }
3473
3474 void
3475 keys_of_keymap ()
3476 {
3477   initial_define_key (global_map, 033, "ESC-prefix");
3478   initial_define_key (global_map, Ctl('X'), "Control-X-prefix");
3479 }