xemacs-beta: src/keymap.c comparison

comparison src/keymap.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	e121b013d1f0
children	489f57a838ef

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 However, bucky bits ("modifiers" to the X-minded) are represented in the
 keymap hierarchy as well. (This lets us use EQable objects as hash keys.)
 Each combination of modifiers (e.g. control-hyper) gets its own submap
 off of the main map.  The hash key for a modifier combination is
 an integer, computed by MAKE_MODIFIER_HASH_KEY().
 If the key `C-a' was bound to some command, the hierarchy would look like
 keymap-1: associates the integer MOD_CONTROL with keymap-2
 keymap-2: associates "a" with the command
 compatibility.
 Since keymaps are opaque, the only way to extract information from them
 is with the functions lookup-key, key-binding, local-key-binding, and
 global-key-binding, which work just as before, and the new function
 map-keymap, which is roughly analagous to maphash.
 Note that map-keymap perpetuates the illusion that the "bucky" submaps
 don't exist: if you map over a keymap with bucky submaps, it will also
 map over those submaps.  It does not, however, map over other random
 submaps of the keymap, just the bucky ones.
 struct lcrecord_header header;
 Lisp_Object parents;		/* Keymaps to be searched after this one
 				 *  An ordered list */
 Lisp_Object prompt;           /* Qnil or a string to print in the minibuffer
 *  when reading from this keymap */
 Lisp_Object table;		/* The contents of this keymap */
 Lisp_Object inverse_table;	/* The inverse mapping of the above */
 Lisp_Object default_binding;  /* Use this if no other binding is found
 *  (this overrides parent maps and the
 Lisp_Object Qtoolbar_map;
 static void describe_command (Lisp_Object definition);
 static void describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
 			  void (*elt_describer) (Lisp_Object),
 			  int partial,
 			  Lisp_Object shadow,
 			  int mice_only_p);
 Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift;
 /* Lisp_Object Qsymbol;	defined in general.c */
 Lisp_Object Qbutton0, Qbutton1, Qbutton2, Qbutton3, Qbutton4, Qbutton5,
 Qbutton6, Qbutton7;
 ((markobj) (keymap->sub_maps_cache));
 ((markobj) (keymap->default_binding));
 ((markobj) (keymap->name));
 return keymap->table;
 }
 static void
 print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 /* This function can GC */
 struct keymap *keymap = XKEYMAP (obj);
 /************************************************************************/
 static unsigned int
 bucky_sym_to_bucky_bit (Lisp_Object sym)
 {
-if (EQ (sym, Qcontrol))
+if (EQ (sym, Qcontrol)) return MOD_CONTROL;
-return MOD_CONTROL;
+if (EQ (sym, Qmeta))    return MOD_META;
-else if (EQ (sym, Qmeta))
+if (EQ (sym, Qsuper))   return MOD_SUPER;
-return MOD_META;
+if (EQ (sym, Qhyper))   return MOD_HYPER;
-else if (EQ (sym, Qsuper))
+if (EQ (sym, Qalt))     return MOD_ALT;
-return MOD_SUPER;
+if (EQ (sym, Qsymbol))  return MOD_ALT; /* #### - reverse compat */
-else if (EQ (sym, Qhyper))
+if (EQ (sym, Qshift))   return MOD_SHIFT;
-return MOD_HYPER;
-else if (EQ (sym, Qalt) || EQ (sym, Qsymbol))	/* #### - reverse compat */
+return 0;
-return MOD_ALT;
-else if (EQ (sym, Qshift))
-return MOD_SHIFT;
-else
-return 0;
 }
 static Lisp_Object
 control_meta_superify (Lisp_Object frob, unsigned int modifiers)
 {
 }
 static void
 keymap_delete_inverse_internal (Lisp_Object inverse_table,
 Lisp_Object keysym,
 Lisp_Object value)
 {
 Lisp_Object keys = Fgethash (value, inverse_table, Qunbound);
 Lisp_Object new_keys = keys;
 Lisp_Object tail;
 Lisp_Object prev_value = Fgethash (keysym, keymap->table, Qnil);
 if (EQ (prev_value, value))
 return;
 if (!NILP (prev_value))
 keymap_delete_inverse_internal (keymap->inverse_table,
 keysym, prev_value);
 if (NILP (value))
 {
 keymap->fullness--;
 if (keymap->fullness < 0) abort ();
 else
 {
 if (NILP (prev_value))
 	keymap->fullness++;
 Fputhash (keysym, value, keymap->table);
 keymap_store_inverse_internal (keymap->inverse_table,
 keysym, value);
 }
 keymap_tick++;
 }
 {
 Lisp_Object *result_locative;
 };
 static void
 keymap_submaps_mapper_0 (CONST void *hash_key, void *hash_contents,
 void *keymap_submaps_closure)
 {
 /* This function can GC */
 Lisp_Object contents;
 VOID_TO_LISP (contents, hash_contents);
 /* Perform any autoloads, etc */
 Fkeymapp (contents);
 }
 static void
 keymap_submaps_mapper (CONST void *hash_key, void *hash_contents,
 void *keymap_submaps_closure)
 {
 /* This function can GC */
 Lisp_Object key, contents;
 Lisp_Object *result_locative;
-struct keymap_submaps_closure *cl = keymap_submaps_closure;
+struct keymap_submaps_closure *cl =
+(struct keymap_submaps_closure *) keymap_submaps_closure;
 CVOID_TO_LISP (key, hash_key);
 VOID_TO_LISP (contents, hash_contents);
 result_locative = cl->result_locative;
 if (!NILP (Fkeymapp (contents)))
 *result_locative = Fcons (Fcons (key, contents), *result_locative);
 }
 static int map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
 Lisp_Object pred);
 static Lisp_Object
 keymap_submaps (Lisp_Object keymap)
 {
 		     &keymap_submaps_closure);
 result = Qnil;
 elisp_maphash (keymap_submaps_mapper, k->table,
 		     &keymap_submaps_closure);
 /* keep it sorted so that the result of accessible-keymaps is ordered */
 k->sub_maps_cache = list_sort (result,
 				     Qnil,
 				     map_keymap_sort_predicate);
 UNGCPRO;
 }
 return k->sub_maps_cache;
 static Lisp_Object
 make_keymap (int size)
 {
 Lisp_Object result = Qnil;
-struct keymap *keymap = alloc_lcrecord (sizeof (struct keymap),
+struct keymap *keymap = alloc_lcrecord_type (struct keymap, lrecord_keymap);
-lrecord_keymap);
 XSETKEYMAP (result, keymap);
 keymap->parents = Qnil;
 keymap->table = Qnil;
 return result;
 }
 DEFUN ("make-keymap", Fmake_keymap, 0, 1, 0, /*
 Construct and return a new keymap object.
-All entries in it are nil, meaning \"command undefined\".
+All entries in it are nil, meaning "command undefined".
 Optional argument NAME specifies a name to assign to the keymap,
 as in `set-keymap-name'.  This name is only a debugging convenience;
 it is not used except when printing the keymap.
 */
 return keymap;
 }
 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, 0, 1, 0, /*
 Construct and return a new keymap object.
-All entries in it are nil, meaning \"command undefined\".  The only
+All entries in it are nil, meaning "command undefined".  The only
 difference between this function and make-keymap is that this function
-returns a \"smaller\" keymap (one that is expected to contain fewer
+returns a "smaller" keymap (one that is expected to contain fewer
 entries).  As keymaps dynamically resize, the distinction is not great.
 Optional argument NAME specifies a name to assign to the keymap,
 as in `set-keymap-name'.  This name is only a debugging convenience;
 it is not used except when printing the keymap.
 {
 keymap = get_keymap (keymap, 1, 1);
 return Fcopy_sequence (XKEYMAP (keymap)->parents);
 }
 static Lisp_Object
 traverse_keymaps_noop (Lisp_Object keymap, void *arg)
 {
 return Qnil;
 }
 when reading a key-sequence to be looked-up in this keymap.
 */
 (keymap, new_prompt))
 {
 keymap = get_keymap (keymap, 1, 1);
 if (!NILP (new_prompt))
 CHECK_STRING (new_prompt);
 XKEYMAP (keymap)->prompt = new_prompt;
 return new_prompt;
 */
 (keymap, command))
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 XKEYMAP (keymap)->default_binding = command;
 return command;
 }
 DEFUN ("keymap-default-binding", Fkeymap_default_binding, 1, 1, 0, /*
 The keymap may be autoloaded first if necessary.
 */
 (object))
 {
 /* This function can GC */
-Lisp_Object tem = get_keymap (object, 0, 1);
+return KEYMAPP (get_keymap (object, 0, 0)) ? Qt : Qnil;
-return KEYMAPP (tem) ? Qt : Qnil;
 }
 /* Check that OBJECT is a keymap (after dereferencing through any
 symbols).  If it is, return it.
 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
 is an autoload form, do the autoload and try again.
+If AUTOLOAD is nonzero, callers must assume GC is possible.
 ERRORP controls how we respond if OBJECT isn't a keymap.
 If ERRORP is non-zero, signal an error; otherwise, just return Qnil.
-*/
+Note that most of the time, we don't want to pursue autoloads.
+Functions like Faccessible_keymaps which scan entire keymap trees
+shouldn't load every autoloaded keymap.  I'm not sure about this,
+but it seems to me that only read_key_sequence, Flookup_key, and
+Fdefine_key should cause keymaps to be autoloaded.  */
 Lisp_Object
 get_keymap (Lisp_Object object, int errorp, int autoload)
 {
 /* This function can GC */
 while (1)
 {
 Lisp_Object tem = indirect_function (object, 0);
 if (KEYMAPP (tem))
 	return tem;
 /* Should we do an autoload?  */
 else if (autoload
 /* (autoload "filename" doc nil keymap) */
 {
 Lisp_Object inverse_table;
 };
 static void
 copy_keymap_inverse_mapper (CONST void *hash_key, void *hash_contents,
 void *copy_keymap_inverse_closure)
 {
 Lisp_Object key, inverse_table, inverse_contents;
-struct copy_keymap_inverse_closure *closure = copy_keymap_inverse_closure;
+struct copy_keymap_inverse_closure *closure =
+(struct copy_keymap_inverse_closure *) copy_keymap_inverse_closure;
 VOID_TO_LISP (inverse_table, closure);
 VOID_TO_LISP (inverse_contents, hash_contents);
 CVOID_TO_LISP (key, hash_key);
 /* copy-sequence deals with dotted lists. */
 {
 struct keymap *self;
 };
 static void
 copy_keymap_mapper (CONST void *hash_key, void *hash_contents,
 void *copy_keymap_closure)
 {
 /* This function can GC */
 Lisp_Object key, contents;
-struct copy_keymap_closure *closure = copy_keymap_closure;
+struct copy_keymap_closure *closure =
+(struct copy_keymap_closure *) copy_keymap_closure;
 CVOID_TO_LISP (key, hash_key);
 VOID_TO_LISP (contents, hash_contents);
 /* When we encounter a keymap which is indirected through a
 symbol, we need to copy the sub-map.  In v18, the form
 	  /* Ok, this is a bit more dubious - prevent people from doing things
 	     like (global-set-key 'RET 'something) because that will have the
 	     same problem as above.  (Gag!)  Maybe we should just silently
 	     accept these as aliases for the "real" names?
 	     */
-	  (string_length (XSYMBOL (*keysym)->name) < 4 &&
+	  (string_length (XSYMBOL (*keysym)->name) <= 3 &&
 	   (!strcmp (name, "LFD") ||
 	    !strcmp (name, "TAB") ||
 	    !strcmp (name, "RET") ||
 	    !strcmp (name, "ESC") ||
 	    !strcmp (name, "DEL") ||
 {
 struct Lisp_Event event;
 event.event_type = empty_event;
 character_to_event (XCHAR_OR_CHAR_INT (spec), &event,
 			  XCONSOLE (Vselected_console), 0);
-returned_value->keysym = event.event.key.keysym;
+returned_value->keysym    = event.event.key.keysym;
 returned_value->modifiers = event.event.key.modifiers;
 }
 else if (EVENTP (spec))
 {
 switch (XEVENT (spec)->event_type)
 	{
 	case key_press_event:
 {
-returned_value->keysym = XEVENT (spec)->event.key.keysym;
+returned_value->keysym    = XEVENT (spec)->event.key.keysym;
 returned_value->modifiers = XEVENT (spec)->event.key.modifiers;
 	    break;
 }
 	case button_press_event:
 	case button_release_event:
 	      case 6:
 		returned_value->keysym = (down ? Qbutton6 : Qbutton6up); break;
 	      case 7:
 		returned_value->keysym = (down ? Qbutton7 : Qbutton7up); break;
 	      default:
-		returned_value->keysym =(down ? Qbutton0 : Qbutton0up); break;
+		returned_value->keysym = (down ? Qbutton0 : Qbutton0up); break;
 	      }
 	    returned_value->modifiers = XEVENT (spec)->event.button.modifiers;
 	    break;
 	  }
 	default:
 return (event_matches_key_specifier_p (XEVENT (event), key_specifier)
 	  ? Qt : Qnil);
 }
 /* ASCII grunge.
 Given a keysym, return another keysym/modifier pair which could be
 considered the same key in an ASCII world.  Backspace returns ^H, for
 example.
 */
 static void
 define_key_alternate_name (struct key_data *key,
 struct key_data *returned_value)
 A key sequence is a vector of keystrokes.  As a degenerate case, elements
 of this vector may also be keysyms if they have no modifiers.  That is,
 the `A' keystroke is represented by all of these forms:
 	A	?A	65	(A)	(?A)	(65)
 	[A]	[?A]	[65]	[(A)]	[(?A)]	[(65)]
 the `control-a' keystroke is represented by these forms:
 	(control A)	(control ?A)	(control 65)
 	[(control A)]	[(control ?A)]	[(control 65)]
 the key sequence `control-c control-a' is represented by these forms:
 	[(control c) (control a)]	[(control ?c) (control ?a)]
 though that is probably not what you want, so be careful.
 For backward compatibility, a key sequence may also be represented by a
 string.  In this case, it represents the key sequence(s) that would
 produce that sequence of ASCII characters in a purely ASCII world.  For
-example, a string containing the ASCII backspace character, \"\\^H\", would
+example, a string containing the ASCII backspace character, "\\^H", would
 represent two key sequences: `(control h)' and `backspace'.  Binding a
 command to this will actually bind both of those key sequences.  Likewise
 for the following pairs:
 		control h	backspace
 		control [   	escape
 		control @	control space
 After binding a command to two key sequences with a form like
-	(define-key global-map \"\\^X\\^I\" \'command-1)
+	(define-key global-map "\\^X\\^I" \'command-1)
 it is possible to redefine only one of those sequences like so:
 	(define-key global-map [(control x) (control i)] \'command-2)
 	(define-key global-map [(control x) tab] \'command-3)
 else
 	{
 	  raw_key2.keysym = Qnil;
 	  raw_key2.modifiers = 0;
 	}
 if (metized)
 	{
 	  raw_key1.modifiers  |= MOD_META;
 	  raw_key2.modifiers |= MOD_META;
 	  metized = 0;
 	  if (ascii_hack && !NILP (raw_key2.keysym))
 	    keymap_store (keymap, &raw_key2, def);
 	  UNGCPRO;
 	  return def;
 	}
 {
 Lisp_Object cmd;
 struct gcpro ngcpro1;
 NGCPRO1 (c);
 /************************************************************************/
 /*                      Looking up keys in keymaps                      */
 /************************************************************************/
 /* We need a very fast (i.e., non-consing) version of lookup-key in order
 to make where-is-internal really fly. */
 struct raw_lookup_key_mapper_closure
 {
 int remaining;
 static Lisp_Object
 raw_lookup_key_mapper (Lisp_Object k, void *arg)
 {
 /* This function can GC */
-struct raw_lookup_key_mapper_closure *c = arg;
+struct raw_lookup_key_mapper_closure *c =
+(struct raw_lookup_key_mapper_closure *) arg;
 int accept_default = c->accept_default;
 int remaining = c->remaining;
 int keys_so_far = c->keys_so_far;
 CONST struct key_data *raw_keys = c->raw_keys;
 Lisp_Object cmd;
 if (! meta_prefix_char_p (&(raw_keys[0])))
 {
 /* Normal case: every case except the meta-hack (see below). */
 cmd = keymap_lookup_1 (k, &(raw_keys[0]), accept_default);
 if (remaining == 0)
 	/* Return whatever we found if we're out of keys */
 	;
 else if (NILP (cmd))
 	/* Found nothing (though perhaps parent map may have binding) */
 	/* Didn't find a keymap, and we have more keys.
 	 * Return a fixnum to indicate that keys were too long.
 	 */
 	cmd = make_int (keys_so_far + 1);
 else
 	cmd = raw_lookup_key (cmd, raw_keys + 1, remaining,
 			      keys_so_far + 1, accept_default);
 }
 else
 {
 /* This is a hack so that looking up a key-sequence whose last
 	{
 	  /* First look for the prefix-char directly */
 	  cmd = keymap_lookup_1 (k, &(raw_keys[0]), accept_default);
 	  if (NILP (cmd))
 	    {
 	      /* Do kludgy return of the meta-map */
 	      cmd = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
 			      XKEYMAP (k)->table, Qnil);
 	    }
 	}
 else
 	{
 	  /* Search for the prefix-char-prefixed sequence directly */
 	  cmd = keymap_lookup_1 (k, &(raw_keys[0]), accept_default);
 	  cmd = get_keymap (cmd, 0, 1);
 	  if (!NILP (cmd))
 	    cmd = raw_lookup_key (cmd, raw_keys + 1, remaining,
 				  keys_so_far + 1, accept_default);
 	  else if ((raw_keys[1].modifiers & MOD_META) == 0)
 	    {
 	      struct key_data metified;
 	      metified.keysym = raw_keys[1].keysym;
 return Qnil;
 if (nkeys < (countof (kkk)))
 raw_keys = kkk;
 else
-raw_keys = (struct key_data *) alloca (sizeof (struct key_data) * nkeys);
+raw_keys = alloca_array (struct key_data, nkeys);
 for (i = 0; i < nkeys; i++)
 {
 define_key_parser (keys[i], &(raw_keys[i]));
 }
 nkeys = event_chain_count (event_head);
 if (nkeys < (countof (kkk)))
 raw_keys = kkk;
 else
-raw_keys = (struct key_data *) alloca (sizeof (struct key_data) * nkeys);
+raw_keys = alloca_array (struct key_data, nkeys);
 nkeys = 0;
 EVENT_CHAIN_LOOP (event, event_head)
 define_key_parser (event, &(raw_keys[nkeys++]));
 GCPRO2 (keymaps[0], event_head);
 DEFUN ("lookup-key", Flookup_key, 2, 3, 0, /*
 In keymap KEYMAP, look up key-sequence KEYS.  Return the definition.
 Nil is returned if KEYS is unbound.  See documentation of `define-key'
 for valid key definitions and key-sequence specifications.
-A number is returned if KEYS is \"too long\"; that is, the leading
+A number is returned if KEYS is "too long"; that is, the leading
 characters fail to be a valid sequence of prefix characters in KEYMAP.
 The number is how many characters at the front of KEYS
 it takes to reach a non-prefix command.
 */
 (keymap, keys, accept_default))
 }
 else /* STRINGP (keys) */
 {
 int length = string_char_length (XSTRING (keys));
 int i;
-struct key_data *raw_keys
+struct key_data *raw_keys = alloca_array (struct key_data, length);
-	= (struct key_data *) alloca (sizeof (struct key_data) * length);
 if (length == 0)
 	return Qnil;
 for (i = 0; i < length; i++)
 	{
 It would be kind of nice if this were in Lisp so that this semi-hairy
 semi-heuristic command-lookup behaviour could be readily understood and
 customised.  However, this needs to be pretty fast, or performance of
 keyboard macros goes to shit; putting this in lisp slows macros down
 2-3x.  And they're already slower than v18 by 5-6x.
 */
 struct relevant_maps
 {
 int nmaps;
 static void get_relevant_minor_maps (Lisp_Object buffer,
 struct relevant_maps *closure);
 static void
 relevant_map_push (Lisp_Object map, struct relevant_maps *closure)
 {
 unsigned int nmaps = closure->nmaps;
 if (!KEYMAPP (map))
 return;
 closure->nmaps = nmaps + 1;
 CHECK_LIVE_EVENT (terminal);
 con = event_console_or_selected (terminal);
 }
 else
 con = XCONSOLE (Vselected_console);
 if (KEYMAPP (con->overriding_terminal_local_map)
 || KEYMAPP (Voverriding_local_map))
 {
 if (KEYMAPP (con->overriding_terminal_local_map))
 	relevant_map_push (con->overriding_terminal_local_map, &closure);
 if (KEYMAPP (Voverriding_local_map))
 	relevant_map_push (Voverriding_local_map, &closure);
 }
 else if (!EVENTP (terminal)
 || (XEVENT (terminal)->event_type != button_press_event
 && XEVENT (terminal)->event_type != button_release_event))
 {
 Lisp_Object tem;
 XSETBUFFER (tem, current_buffer);
 /* It's not a mouse event; order of keymaps searched is:
 {
 Lisp_Object keymap = Fextent_property (glyph, Qkeymap, Qnil);
 if (!NILP (keymap))
 	relevant_map_push (get_keymap (keymap, 1, 1), closure);
 }
 /* Next check the extents at the text position, if any */
 if (!NILP (pos))
 {
 Lisp_Object extent;
 for (extent = Fextent_at (pos, buffer_or_string, Qkeymap, Qnil, Qat);
 GCPRO1 (event_or_keys);
 nmaps = get_relevant_keymaps (event_or_keys, countof (maps),
 				gubbish);
 if (nmaps > countof (maps))
 {
-gubbish = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
+gubbish = alloca_array (Lisp_Object, nmaps);
 nmaps = get_relevant_keymaps (event_or_keys, nmaps, gubbish);
 }
 UNGCPRO;
 return Flist (nmaps, gubbish);
 }
 Lisp_Object
 event_binding_in (Lisp_Object event0, Lisp_Object keymap, int accept_default)
 {
 /* This function can GC */
-Lisp_Object maps[1];
 if (!KEYMAPP (keymap))
 return Qnil;
-maps[0] = keymap;
+return process_event_binding_result (lookup_events (event0, 1, &keymap,
-return process_event_binding_result (lookup_events (event0, 1, maps,
 						      accept_default));
 }
 /* Attempts to find a function key mapping corresponding to the
 event-sequence whose head is event0 (sequence is threaded through
 event_next).  The return value will be the same as for event_binding(). */
 Lisp_Object
 munging_key_map_event_binding (Lisp_Object event0,
 			       enum munge_me_out_the_door munge)
 {
-Lisp_Object the_map;
+Lisp_Object keymap = (munge == MUNGE_ME_FUNCTION_KEY) ?
-Lisp_Object maps[1];
+CONSOLE_FUNCTION_KEY_MAP (event_console_or_selected (event0)) :
+Vkey_translation_map;
-if (munge == MUNGE_ME_FUNCTION_KEY)
-{
+if (NILP (keymap))
-struct console *c = event_console_or_selected (event0);
-the_map = CONSOLE_FUNCTION_KEY_MAP (c);
-}
-else
-the_map = Vkey_translation_map;
-if (NILP (the_map))
 return Qnil;
-maps[0] = the_map;
+return process_event_binding_result (lookup_events (event0, 1, &keymap, 1));
-return process_event_binding_result (lookup_events (event0, 1, maps, 1));
 }
 /************************************************************************/
 /*               Setting/querying the global and local maps             */
 /************************************************************************/
 /*                    Mapping over keymap elements                      */
 /************************************************************************/
 /* Since keymaps are arranged in a hierarchy, one keymap per bucky bit or
-prefix key, it's not entirely objvious what map-keymap should do, but
+prefix key, it's not entirely obvious what map-keymap should do, but
 what it does is: map over all keys in this map; then recursively map
 over all submaps of this map that are "bucky" submaps.  This means that,
 when mapping over a keymap, it appears that "x" and "C-x" are in the
 same map, although "C-x" is really in the "control" submap of this one.
 However, since we don't recursively descend the submaps that are bound
 unsigned int modifiers;
 };
 /* used by map_keymap() */
 static void
 map_keymap_unsorted_mapper (CONST void *hash_key, void *hash_contents,
 void *map_keymap_unsorted_closure)
 {
 /* This function can GC */
 Lisp_Object keysym;
 Lisp_Object contents;
-struct map_keymap_unsorted_closure *closure = map_keymap_unsorted_closure;
+struct map_keymap_unsorted_closure *closure =
+(struct map_keymap_unsorted_closure *) map_keymap_unsorted_closure;
 unsigned int modifiers = closure->modifiers;
 unsigned int mod_bit;
 CVOID_TO_LISP (keysym, hash_key);
 VOID_TO_LISP (contents, hash_contents);
 mod_bit = MODIFIER_HASH_KEY_BITS (keysym);
 if (mod_bit != 0)
 {
 int omod = modifiers;
 closure->modifiers = (modifiers | mod_bit);
-contents = get_keymap (contents, 1, 1);
+contents = get_keymap (contents, 1, 0);
 elisp_maphash (map_keymap_unsorted_mapper,
 		     XKEYMAP (contents)->table,
 		     map_keymap_unsorted_closure);
 closure->modifiers = omod;
 }
 Lisp_Object *result_locative;
 };
 /* used by map_keymap_sorted() */
 static void
 map_keymap_sorted_mapper (CONST void *hash_key, void *hash_contents,
 void *map_keymap_sorted_closure)
 {
-struct map_keymap_sorted_closure *cl = map_keymap_sorted_closure;
+struct map_keymap_sorted_closure *cl =
+(struct map_keymap_sorted_closure *) map_keymap_sorted_closure;
 Lisp_Object key, contents;
 Lisp_Object *list = cl->result_locative;
 CVOID_TO_LISP (key, hash_key);
 VOID_TO_LISP (contents, hash_contents);
 *list = Fcons (Fcons (key, contents), *list);
 /* used by map_keymap_sorted(), describe_map_sort_predicate(),
 and keymap_submaps().
 */
 static int
 map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
 Lisp_Object pred)
 {
 /* obj1 and obj2 are conses with keysyms in their cars.  Cdrs are ignored.
 */
 unsigned int bit1, bit2;
 if (EQ (obj1, obj2))
 return -1;
 bit1 = MODIFIER_HASH_KEY_BITS (obj1);
 bit2 = MODIFIER_HASH_KEY_BITS (obj2);
 /* If either is a symbol with a character-set-property, then sort it by
 that code instead of alphabetically.
 */
 if (! bit1 && SYMBOLP (obj1))
 {
 }
 /* else they're both symbols.  If they're both buckys, then order them. */
 if (bit1 && bit2)
 return bit1 < bit2 ? 1 : -1;
 /* if only one is a bucky, then it comes later */
 if (bit1 || bit2)
 return bit2 ? 1 : -1;
 /* otherwise, string-sort them. */
 /* used by map_keymap() */
 static void
 map_keymap_sorted (Lisp_Object keymap_table,
 unsigned int modifiers,
 void (*function) (CONST struct key_data *key,
 Lisp_Object binding,
 void *map_keymap_sorted_closure),
 void *map_keymap_sorted_closure)
 {
 /* This function can GC */
 struct gcpro gcpro1;
 /* used by Fmap_keymap() */
 static void
 map_keymap_mapper (CONST struct key_data *key,
 Lisp_Object binding,
 void *function)
 {
 /* This function can GC */
 Lisp_Object fn;
 VOID_TO_LISP (fn, function);
 the keymap will ever be passed to the function more than once.
 The function will not be called on elements of this keymap's parents
 (see the function `keymap-parents') or upon keymaps which are contained
 within this keymap (multi-character definitions).
-It will be called on \"meta\" characters since they are not really
+It will be called on "meta" characters since they are not really
 two-character sequences.
 If the optional third argument SORT-FIRST is non-nil, then the elements of
 the keymap will be passed to the mapper function in a canonical order.
 Otherwise, they will be passed in hash (that is, random) order, which is
 static Lisp_Object
 accessible_keymaps_keymap_mapper (Lisp_Object thismap, void *arg)
 {
 /* This function can GC */
-struct accessible_keymaps_closure *closure = arg;
+struct accessible_keymaps_closure *closure =
+(struct accessible_keymaps_closure *) arg;
 Lisp_Object submaps = keymap_submaps (thismap);
 for (; !NILP (submaps); submaps = XCDR (submaps))
 {
 accessible_keymaps_mapper_1 (XCAR (XCAR (submaps)),
 return Qnil;
 }
 DEFUN ("accessible-keymaps", Faccessible_keymaps, 1, 2, 0, /*
-Find all keymaps accessible via prefix characters from STARTMAP.
+Find all keymaps accessible via prefix characters from KEYMAP.
 Returns a list of elements of the form (KEYS . MAP), where the sequence
-KEYS starting from STARTMAP gets you to MAP.  These elements are ordered
+KEYS starting from KEYMAP gets you to MAP.  These elements are ordered
-so that the KEYS increase in length.  The first element is ([] . STARTMAP).
+so that the KEYS increase in length.  The first element is ([] . KEYMAP).
 An optional argument PREFIX, if non-nil, should be a key sequence;
 then the value includes only maps for prefixes that start with PREFIX.
 */
-(startmap, prefix))
+(keymap, prefix))
 {
 /* This function can GC */
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 Lisp_Object accessible_keymaps = Qnil;
 struct accessible_keymaps_closure c;
 c.tail = Qnil;
-GCPRO4 (accessible_keymaps, c.tail, prefix, startmap);
+GCPRO4 (accessible_keymaps, c.tail, prefix, keymap);
 retry:
-startmap = get_keymap (startmap, 1, 1);
+keymap = get_keymap (keymap, 1, 1);
 if (NILP (prefix))
 prefix = make_vector (0, Qnil);
 else if (!VECTORP (prefix) || STRINGP (prefix))
 {
 prefix = wrong_type_argument (Qarrayp, prefix);
 goto retry;
 }
 else
 {
 int len = XINT (Flength (prefix));
-Lisp_Object def = Flookup_key (startmap, prefix, Qnil);
+Lisp_Object def = Flookup_key (keymap, prefix, Qnil);
 Lisp_Object p;
 int iii;
 struct gcpro ngcpro1;
 def = get_keymap (def, 0, 1);
 if (!KEYMAPP (def))
 	goto RETURN;
-startmap = def;
+keymap = def;
 p = make_vector (len, Qnil);
 NGCPRO1 (p);
 for (iii = 0; iii < len; iii++)
 	{
 	  struct key_data key;
 	  XVECTOR_DATA (p)[iii] = make_key_description (&key, 1);
 	}
 NUNGCPRO;
 prefix = p;
 }
-accessible_keymaps = list1 (Fcons (prefix, startmap));
+accessible_keymaps = list1 (Fcons (prefix, keymap));
 /* For each map in the list maps,
 look at any other maps it points to
 and stick them at the end if they are not already in the list */
 /*              Pretty descriptions of key sequences                    */
 /************************************************************************/
 DEFUN ("key-description", Fkey_description, 1, 1, 0, /*
 Return a pretty description of key-sequence KEYS.
-Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"
+Control characters turn into "C-foo" sequences, meta into "M-foo",
-spaces are put between sequence elements, etc.
+spaces are put between sequence elements, etc...
 */
 (keys))
 {
 if (CHAR_OR_CHAR_INTP (keys) || CONSP (keys) || SYMBOLP (keys)
 || EVENTP (keys))
 	    }
 	  else
 	    {
 	      CHECK_SYMBOL (keysym);
 #if 0                           /* This is bogus */
-	      if (EQ (keysym, QKlinefeed))	strcpy (bufp, "LFD");
+	      if (EQ (keysym, QKlinefeed))	 strcpy (bufp, "LFD");
-	      else if (EQ (keysym, QKtab))	strcpy (bufp, "TAB");
+	      else if (EQ (keysym, QKtab))	 strcpy (bufp, "TAB");
-	      else if (EQ (keysym, QKreturn))	strcpy (bufp, "RET");
+	      else if (EQ (keysym, QKreturn))	 strcpy (bufp, "RET");
-	      else if (EQ (keysym, QKescape))	strcpy (bufp, "ESC");
+	      else if (EQ (keysym, QKescape))	 strcpy (bufp, "ESC");
-	      else if (EQ (keysym, QKdelete))	strcpy (bufp, "DEL");
+	      else if (EQ (keysym, QKdelete))	 strcpy (bufp, "DEL");
-	      else if (EQ (keysym, QKspace))	strcpy (bufp, "SPC");
+	      else if (EQ (keysym, QKspace))	 strcpy (bufp, "SPC");
-	      else if (EQ (keysym, QKbackspace))	strcpy (bufp, "BS");
+	      else if (EQ (keysym, QKbackspace)) strcpy (bufp, "BS");
 	      else
 #endif
 		strcpy (bufp, (char *) string_data (XSYMBOL (keysym)->name));
 	      if (!NILP (XCDR (rest)))
 		signal_simple_error ("invalid key description",
 (wrong_type_argument (intern ("char-or-event-p"), key));
 }
 DEFUN ("text-char-description", Ftext_char_description, 1, 1, 0, /*
 Return a pretty description of file-character CHR.
-Unprintable characters turn into \"^char\" or \\NNN, depending on the value
+Unprintable characters turn into "^char" or \\NNN, depending on the value
 of the `ctl-arrow' variable.
 This differs from `single-key-description' in that it returns a description
 of a character from a buffer rather than a key read from the user.
 */
 (chr))
 {
 nmaps = get_relevant_keymaps (event_or_keys, countof (maps),
 				    gubbish);
 if (nmaps > countof (maps))
 	{
-	  gubbish = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
+	  gubbish = alloca_array (Lisp_Object, nmaps);
 	  nmaps = get_relevant_keymaps (event_or_keys, nmaps, gubbish);
 	}
 }
 else if (CONSP (keymaps))
 {
 int i;
 nmaps = XINT (Flength (keymaps));
 if (nmaps > countof (maps))
 	{
-	  gubbish = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
+	  gubbish = alloca_array (Lisp_Object, nmaps);
 	}
 for (rest = keymaps, i = 0; !NILP (rest);
 	   rest = XCDR (keymaps), i++)
 	{
 	  gubbish[i] = get_keymap (XCAR (keymaps), 1, 1);
 	{
 	  gubbish[1] = Vcurrent_global_map;
 	  nmaps++;
 	}
 }
 return where_is_internal (definition, gubbish, nmaps, firstonly, 0);
 }
 /* This function is like
 (key-description (where-is-internal definition nil t))
 except that it writes its output into a (char *) buffer that you
 provide; it doesn't cons (or allocate memory) at all, so it's
 very fast.  This is used by menubar.c.
 */
 void
 where_is_to_char (Lisp_Object definition, char *buffer)
 /* Get keymaps as an array */
 nmaps = get_relevant_keymaps (Qnil, countof (maps), gubbish);
 if (nmaps > countof (maps))
 {
-gubbish = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
+gubbish = alloca_array (Lisp_Object, nmaps);
 nmaps = get_relevant_keymaps (Qnil, nmaps, gubbish);
 }
 buffer[0] = 0;
 where_is_internal (definition, maps, nmaps, Qt, buffer);
 }
 static Lisp_Object
 raw_keys_to_keys (struct key_data *keys, int count)
 {
 Lisp_Object result = make_vector (count, Qnil);
 while (count--)
 XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1);
 If we're in the "meta" submap of the map that "C-x 4" is bound to,
 then keys_so_far will be {(control x), \4}, and modifiers_so_far
 will be MOD_META.  That is, keys_so_far is the chain of keys that we
 have followed, and modifiers_so_far_so_far is the bits (partial keys)
 beyond that.
 (keys_so_far is a global buffer and the keys_count arg says how much
 of it we're currently interested in.)
 If target_buffer is provided, then we write a key-description into it,
 to avoid consing a string.  This only works with firstonly on.
 */
 struct where_is_closure
 static Lisp_Object
 where_is_recursive_mapper (Lisp_Object map, void *arg)
 {
 /* This function can GC */
-struct where_is_closure *c = arg;
+struct where_is_closure *c = (struct where_is_closure *) arg;
 Lisp_Object definition = c->definition;
 CONST int firstonly = c->firstonly;
 CONST unsigned int keys_count = c->keys_count;
 CONST unsigned int modifiers_so_far = c->modifiers_so_far;
 char *target_buffer = c->target_buffer;
 Lisp_Object submaps;
 Lisp_Object result = Qnil;
 if (!NILP (keys))
 {
-/* One or more keys in this map match the definition we're looking
+/* One or more keys in this map match the definition we're looking for.
-	 for.  Verify that these bindings aren't shadowed by other bindings
+	 Verify that these bindings aren't shadowed by other bindings
 	 in the shadow maps.  Either nil or number as value from
-	 raw_lookup_key() means undefined.
+	 raw_lookup_key() means undefined.  */
-	 */
 struct key_data *so_far = c->keys_so_far;
 for (;;) /* loop over all keys that match */
 	{
 	  Lisp_Object k = ((CONSP (keys)) ? XCAR (keys) : keys);
 	  int i;
 	  so_far [keys_count].keysym = k;
 	  so_far [keys_count].modifiers = modifiers_so_far;
 	  /* now loop over all shadow maps */
 	  for (i = 0; i < c->shadow_count; i++)
 	    {
 	      Lisp_Object shadowed = raw_lookup_key (c->shadow[i],
 						     so_far,
 						     keys_count + 1,
 						     0, 1);
 	      if (NILP (shadowed) || CHARP (shadowed) ||
 		  EQ (shadowed, definition))
 		continue; /* we passed this test; it's not shadowed here. */
 	  keys = XCDR (keys);
 	}
 }
 /* Now search the sub-keymaps of this map.
 If we're in "firstonly" mode and have already found one, this
 point is not reached.  If we get one from lower down, either
 return it immediately (in firstonly mode) or tack it onto the
 end of the ones we've gotten so far.
 */
 for (submaps = keymap_submaps (map);
 Lisp_Object submap = XCDR (XCAR (submaps));
 unsigned int lower_modifiers;
 int lower_keys_count = keys_count;
 unsigned int bucky;
-submap = get_keymap (submap, 0, 1);
+submap = get_keymap (submap, 0, 0);
 if (EQ (submap, map))
 	/* Arrgh!  Some loser has introduced a loop... */
 	continue;
 if (lower_keys_count >= c->keys_so_far_total_size)
 	{
 	  int size = lower_keys_count + 50;
 	  if (! c->keys_so_far_malloced)
 	    {
-	      struct key_data *new = xmalloc (size * sizeof (struct key_data));
+	      struct key_data *new = xnew_array (struct key_data, size);
 	      memcpy ((void *)new, (const void *)c->keys_so_far,
 		      c->keys_so_far_total_size * sizeof (struct key_data));
 	    }
 	  else
-	    c->keys_so_far = xrealloc (c->keys_so_far,
+	    XREALLOC_ARRAY (c->keys_so_far, struct key_data, size);
-				       size * sizeof (struct key_data));
 	  c->keys_so_far_total_size = size;
 	  c->keys_so_far_malloced = 1;
 	}
 	Lisp_Object lower;
 	c->keys_count = lower_keys_count;
 	c->modifiers_so_far = lower_modifiers;
-	lower = traverse_keymaps (submap, Qnil, where_is_recursive_mapper,
+	lower = traverse_keymaps (submap, Qnil, where_is_recursive_mapper, c);
-				  c);
 	c->keys_count = keys_count;
 	c->modifiers_so_far = modifiers_so_far;
 	if (!firstonly)
 	  result = nconc2 (lower, result);
 /*                         Describing keymaps                           */
 /************************************************************************/
 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal, 1, 5, 0, /*
 Insert a list of all defined keys and their definitions in MAP.
-Optional second argument ALL says whether to include even \"uninteresting\"
+Optional second argument ALL says whether to include even "uninteresting"
 definitions (ie symbols with a non-nil `suppress-keymap' property.
 Third argument SHADOW is a list of keymaps whose bindings shadow those
 of map; if a binding is present in any shadowing map, it is not printed.
 Fourth argument PREFIX, if non-nil, should be a key sequence;
 only bindings which start with that key sequence will be printed.
 followed by those of all maps reachable through STARTMAP.
 If PARTIAL is nonzero, omit certain "uninteresting" commands
 (such as `undefined').
 If SHADOW is non-nil, it is a list of other maps;
 don't mention keys which would be shadowed by any of them
-If PREFIX is non-nil, only list bindings which start with those keys
+If PREFIX is non-nil, only list bindings which start with those keys.
 */
 void
 describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
 Lisp_Object prefix, int mice_only_p)
 for (; !NILP (maps); maps = Fcdr (maps))
 {
 Lisp_Object sub_shadow = Qnil;
 Lisp_Object elt = Fcar (maps);
-Lisp_Object tail = shadow;
+Lisp_Object tail;
 int no_prefix = (VECTORP (Fcar (elt))
 && XINT (Flength (Fcar (elt))) == 0);
 struct gcpro ngcpro1, ngcpro2, ngcpro3;
 NGCPRO3 (sub_shadow, elt, tail);
-for (; CONSP (tail); tail = XCDR (tail))
+for (tail = shadow; CONSP (tail); tail = XCDR (tail))
 	{
-	  Lisp_Object sh = XCAR (tail);
+	  Lisp_Object shmap = XCAR (tail);
 	  /* If the sequence by which we reach this keymap is zero-length,
 	     then the shadow maps for this keymap are just SHADOW.  */
 	  if (no_prefix)
 	    ;
 	  /* If the sequence by which we reach this keymap actually has
 	     some elements, then the sequence's definition in SHADOW is
 	     what we should use.  */
 	  else
 	    {
-	      sh = Flookup_key (sh, Fcar (elt), Qt);
+	      shmap = Flookup_key (shmap, Fcar (elt), Qt);
-	      if (CHARP (sh))
+	      if (CHARP (shmap))
-		sh = Qnil;
+		shmap = Qnil;
 	    }
-	  if (!NILP (sh))
+	  if (!NILP (shmap))
 	    {
-	      Lisp_Object shm = get_keymap (sh, 0, 1);
+	      Lisp_Object shm = get_keymap (shmap, 0, 1);
+	      /* If shmap is not nil and not a keymap, it completely
+		 shadows this map, so don't describe this map at all.  */
 	      if (!KEYMAPP (shm))
-		/* If sh is not nil and not a keymap, it completely shadows
-		   this map, so don't describe this map at all.  */
 		goto SKIP;
 	      sub_shadow = Fcons (shm, sub_shadow);
 	    }
 	}
 {
 Lisp_Object name = XKEYMAP (definition)->name;
 if (STRINGP (name) || (SYMBOLP (name) && !NILP (name)))
 	{
 	  buffer_insert_c_string (XBUFFER (buffer), "Prefix command ");
 	  if (SYMBOLP (name)
 	      && EQ (find_symbol_value (name), definition))
 	    buffer_insert1 (XBUFFER (buffer), Fsymbol_name (name));
 	  else
 	    {
 	      buffer_insert1 (XBUFFER (buffer), Fprin1_to_string (name, Qnil));
 };
 static Lisp_Object
 describe_map_mapper_shadow_search (Lisp_Object map, void *arg)
 {
-struct describe_map_shadow_closure *c = arg;
+struct describe_map_shadow_closure *c =
+(struct describe_map_shadow_closure *) arg;
 if (EQ (map, c->self))
 return Qzero;		/* Not shadowed; terminate search */
-if (!NILP (keymap_lookup_directly (map,
-				     c->raw_key->keysym,
+return (!NILP (keymap_lookup_directly (map,
-				     c->raw_key->modifiers)))
+					 c->raw_key->keysym,
-return Qt;
+					 c->raw_key->modifiers)))
-else
+? Qt : Qnil;
-return Qnil;
+}
-}
 static Lisp_Object
 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg)
 {
-struct key_data *k = arg;
+struct key_data *k = (struct key_data *) arg;
 return keymap_lookup_directly (km, k->keysym, k->modifiers);
 }
 static void
 describe_map_mapper (CONST struct key_data *key,
 Lisp_Object binding,
 		     void *describe_map_closure)
 {
 /* This function can GC */
-struct describe_map_closure *closure = describe_map_closure;
+struct describe_map_closure *closure =
+(struct describe_map_closure *) describe_map_closure;
 Lisp_Object keysym = key->keysym;
 unsigned int modifiers = key->modifiers;
 /* Dont mention suppressed commands.  */
 if (SYMBOLP (binding)
 && !NILP (closure->partial)
 && !NILP (Fget (binding, closure->partial, Qnil)))
 return;
 /* If we're only supposed to display mouse bindings and this isn't one,
 then bug out. */
 if (closure->mice_only_p &&
-(! (EQ (keysym, Qbutton0) || EQ (keysym, Qbutton1)
+(! (EQ (keysym, Qbutton0) ||
-|| EQ (keysym, Qbutton2) || EQ (keysym, Qbutton3)
+	  EQ (keysym, Qbutton1) ||
-|| EQ (keysym, Qbutton4) || EQ (keysym, Qbutton5)
+	  EQ (keysym, Qbutton2) ||
-|| EQ (keysym, Qbutton6) || EQ (keysym, Qbutton7))))
+	  EQ (keysym, Qbutton3) ||
+	  EQ (keysym, Qbutton4) ||
+	  EQ (keysym, Qbutton5) ||
+	  EQ (keysym, Qbutton6) ||
+	  EQ (keysym, Qbutton7))))
 return;
 /* If this command in this map is shadowed by some other map, ignore it. */
 {
 Lisp_Object tail;
 			    *(closure->list));
 }
 static int
 describe_map_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
 			     Lisp_Object pred)
 {
 /* obj1 and obj2 are conses of the form
 ( ( <keysym> . <modifiers> ) . <binding> )
 keysym and modifiers are used, binding is ignored.
 	  CHECK_CHAR_COERCE_INT (s2);
 	}
 else return 0;
 }
-if (XCHAR (s1) == XCHAR (s2) ||
+return (XCHAR (s1)     == XCHAR (s2) ||
-XCHAR (s1) + 1 == XCHAR (s2))
+	  XCHAR (s1) + 1 == XCHAR (s2));
-return 1;
-return 0;
 }
 static Lisp_Object
 describe_map_parent_mapper (Lisp_Object keymap, void *arg)
 {
 /* This function can GC */
-struct describe_map_closure *describe_map_closure = arg;
+struct describe_map_closure *describe_map_closure =
+(struct describe_map_closure *) arg;
 describe_map_closure->self = keymap;
 map_keymap (XKEYMAP (keymap)->table,
 0, /* don't sort: we'll do it later */
 describe_map_mapper, describe_map_closure);
 return Qnil;
 }
+/* Describe the contents of map MAP, assuming that this map itself is
+reached by the sequence of prefix keys KEYS (a string or vector).
+PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above.  */
 static void
 describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
 	      void (*elt_describer) (Lisp_Object),
 	      int partial,
 	      Lisp_Object shadow,
 	      int mice_only_p)
 {
 /* This function can GC */
 struct describe_map_closure describe_map_closure;
 		buffer_insert_c_string (buf, "DEL");
 	      else if (EQ (keysym, QKspace))
 		buffer_insert_c_string (buf, "SPC");
 	      else if (EQ (keysym, QKbackspace))
 		buffer_insert_c_string (buf, "BS");
 	      else
 #endif
 if (c >= printable_min)
 		  buffer_insert_emacs_char (buf, c);
 		else buffer_insert1 (buf, Fsymbol_name (keysym));
 	    }
 DEFSUBR (Ftext_char_description);
 defsymbol (&Qcontrol, "control");
 defsymbol (&Qctrl, "ctrl");
 defsymbol (&Qmeta, "meta");
 defsymbol (&Qsuper, "super");
 defsymbol (&Qhyper, "hyper");
 defsymbol (&Qalt, "alt");
 defsymbol (&Qshift, "shift");
 defsymbol (&Qbutton0, "button0");
 defsymbol (&Qbutton1, "button1");
 defsymbol (&Qbutton2, "button2");

Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 185:3d6bfa290dbd r20-3b19